Merge branch '2.1.x'

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/ConfigurationMetadataAnnotationProcessor.java

 /*
- * Copyright 2012-2018 the original author or authors.
+ * Copyright 2012-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -292,7 +292,7 @@ public class ConfigurationMetadataAnnotationProcessor extends AbstractProcessor
 			boolean isNested = isNested(returnTypeElement, field, element);
 			boolean isCollection = this.typeUtils.isCollectionOrMap(returnType);
 			if (!isExcluded && !isNested && (setter != null || isCollection)) {
-				String dataType = this.typeUtils.getType(returnType);
+				String dataType = this.typeUtils.getType(element, returnType);
 				String sourceType = this.typeUtils.getQualifiedName(element);
 				String description = this.typeUtils.getJavaDoc(field);
 				Object defaultValue = fieldValues.get(name);
@@ -335,7 +335,7 @@ public class ConfigurationMetadataAnnotationProcessor extends AbstractProcessor
 			boolean isCollection = this.typeUtils.isCollectionOrMap(returnType);
 			boolean hasSetter = hasLombokSetter(field, element);
 			if (!isExcluded && !isNested && (hasSetter || isCollection)) {
-				String dataType = this.typeUtils.getType(returnType);
+				String dataType = this.typeUtils.getType(element, returnType);
 				String sourceType = this.typeUtils.getQualifiedName(element);
 				String description = this.typeUtils.getJavaDoc(field);
 				Object defaultValue = fieldValues.get(name);

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/TypeUtils.java

 /*
- * Copyright 2012-2018 the original author or authors.
+ * Copyright 2012-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,7 +21,9 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.EnumMap;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -33,8 +35,10 @@ import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.PrimitiveType;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVariable;
 import javax.lang.model.util.SimpleTypeVisitor8;
 import javax.lang.model.util.Types;
+import javax.tools.Diagnostic.Kind;
 
 /**
  * Type Utilities.
@@ -73,18 +77,22 @@ class TypeUtils {
 
 	private final ProcessingEnvironment env;
 
+	private final Types types;
+
 	private final TypeExtractor typeExtractor;
 
 	private final TypeMirror collectionType;
 
 	private final TypeMirror mapType;
 
+	private final Map<TypeElement, TypeDescriptor> typeDescriptors = new HashMap<>();
+
 	TypeUtils(ProcessingEnvironment env) {
 		this.env = env;
-		Types types = env.getTypeUtils();
-		this.typeExtractor = new TypeExtractor(types);
-		this.collectionType = getDeclaredType(types, Collection.class, 1);
-		this.mapType = getDeclaredType(types, Map.class, 2);
+		this.types = env.getTypeUtils();
+		this.typeExtractor = new TypeExtractor(this.types);
+		this.collectionType = getDeclaredType(this.types, Collection.class, 1);
+		this.mapType = getDeclaredType(this.types, Map.class, 2);
 	}
 
 	private TypeMirror getDeclaredType(Types types, Class<?> typeClass,
@@ -115,14 +123,15 @@ class TypeUtils {
 	/**
 	 * Return the type of the specified {@link TypeMirror} including all its generic
 	 * information.
+	 * @param element the {@link TypeElement} in which this {@code type} is declared
 	 * @param type the type to handle
 	 * @return a representation of the type including all its generic information
 	 */
-	public String getType(TypeMirror type) {
+	public String getType(TypeElement element, TypeMirror type) {
 		if (type == null) {
 			return null;
 		}
-		return type.accept(this.typeExtractor, null);
+		return type.accept(this.typeExtractor, createTypeDescriptor(element));
 	}
 
 	public boolean isCollectionOrMap(TypeMirror type) {
@@ -160,11 +169,49 @@ class TypeUtils {
 		return WRAPPER_TO_PRIMITIVE.get(type.toString());
 	}
 
+	TypeDescriptor resolveTypeDescriptor(TypeElement element) {
+		if (this.typeDescriptors.containsKey(element)) {
+			return this.typeDescriptors.get(element);
+		}
+		return createTypeDescriptor(element);
+	}
+
+	private TypeDescriptor createTypeDescriptor(TypeElement element) {
+		TypeDescriptor descriptor = new TypeDescriptor();
+		process(descriptor, element.asType());
+		this.typeDescriptors.put(element, descriptor);
+		return descriptor;
+	}
+
+	private void process(TypeDescriptor descriptor, TypeMirror type) {
+		try {
+			if (type.getKind() == TypeKind.DECLARED) {
+				DeclaredType declaredType = (DeclaredType) type;
+				DeclaredType freshType = (DeclaredType) this.env.getElementUtils()
+						.getTypeElement(this.types.asElement(type).toString()).asType();
+				List<? extends TypeMirror> arguments = declaredType.getTypeArguments();
+				for (int i = 0; i < arguments.size(); i++) {
+					TypeMirror specificType = arguments.get(i);
+					TypeMirror signatureType = freshType.getTypeArguments().get(i);
+					descriptor.registerIfNecessary(signatureType, specificType);
+				}
+				TypeElement element = (TypeElement) this.types.asElement(type);
+				process(descriptor, element.getSuperclass());
+			}
+		}
+		catch (Exception ex) {
+			this.env.getMessager().printMessage(Kind.WARNING,
+					"Failed to generated type descriptor for " + type,
+					this.types.asElement(type));
+		}
+	}
+
 	/**
 	 * A visitor that extracts the fully qualified name of a type, including generic
 	 * information.
 	 */
-	private static class TypeExtractor extends SimpleTypeVisitor8<String, Void> {
+	private static class TypeExtractor
+			extends SimpleTypeVisitor8<String, TypeDescriptor> {
 
 		private final Types types;
 
@@ -173,34 +220,60 @@ class TypeUtils {
 		}
 
 		@Override
-		public String visitDeclared(DeclaredType type, Void none) {
+		public String visitDeclared(DeclaredType type, TypeDescriptor descriptor) {
 			TypeElement enclosingElement = getEnclosingTypeElement(type);
-			if (enclosingElement != null) {
-				return getQualifiedName(enclosingElement) + "$"
-						+ type.asElement().getSimpleName();
-			}
-			String qualifiedName = getQualifiedName(type.asElement());
+			String qualifiedName = determineQualifiedName(type, enclosingElement);
 			if (type.getTypeArguments().isEmpty()) {
 				return qualifiedName;
 			}
 			StringBuilder name = new StringBuilder();
 			name.append(qualifiedName);
 			name.append("<").append(type.getTypeArguments().stream()
-					.map(TypeMirror::toString).collect(Collectors.joining(",")))
+					.map((t) -> visit(t, descriptor)).collect(Collectors.joining(",")))
 					.append(">");
 			return name.toString();
 		}
 
+		private String determineQualifiedName(DeclaredType type,
+				TypeElement enclosingElement) {
+			if (enclosingElement != null) {
+				return getQualifiedName(enclosingElement) + "$"
+						+ type.asElement().getSimpleName();
+			}
+			return getQualifiedName(type.asElement());
+		}
+
+		@Override
+		public String visitTypeVariable(TypeVariable t, TypeDescriptor descriptor) {
+			TypeMirror typeMirror = descriptor.resolveGeneric(t);
+			if (typeMirror != null) {
+				if (typeMirror instanceof TypeVariable) {
+					// Still unresolved, let's use upper bound
+					return visit(((TypeVariable) typeMirror).getUpperBound(), descriptor);
+				}
+				else {
+					return visit(typeMirror, descriptor);
+				}
+			}
+			// Unresolved generics, use upper bound
+			return visit(t.getUpperBound(), descriptor);
+		}
+
 		@Override
-		public String visitArray(ArrayType t, Void none) {
-			return t.getComponentType().accept(this, none) + "[]";
+		public String visitArray(ArrayType t, TypeDescriptor descriptor) {
+			return t.getComponentType().accept(this, descriptor) + "[]";
 		}
 
 		@Override
-		public String visitPrimitive(PrimitiveType t, Void none) {
+		public String visitPrimitive(PrimitiveType t, TypeDescriptor descriptor) {
 			return this.types.boxedClass(t).getQualifiedName().toString();
 		}
 
+		@Override
+		protected String defaultAction(TypeMirror t, TypeDescriptor descriptor) {
+			return t.toString();
+		}
+
 		public String getQualifiedName(Element element) {
 			if (element == null) {
 				return null;
@@ -230,4 +303,42 @@ class TypeUtils {
 
 	}
 
+	/**
+	 * Descriptor for a given type.
+	 */
+	static class TypeDescriptor {
+
+		private final Map<TypeVariable, TypeMirror> generics = new HashMap<>();
+
+		public Map<TypeVariable, TypeMirror> getGenerics() {
+			return Collections.unmodifiableMap(this.generics);
+		}
+
+		public TypeMirror resolveGeneric(TypeVariable typeVariable) {
+			return resolveGeneric(getParameterName(typeVariable));
+		}
+
+		public TypeMirror resolveGeneric(String parameterName) {
+			return this.generics.entrySet().stream()
+					.filter((e) -> getParameterName(e.getKey()).equals(parameterName))
+					.findFirst().map(Entry::getValue).orElse(null);
+		}
+
+		private void registerIfNecessary(TypeMirror variable, TypeMirror resolution) {
+			if (variable instanceof TypeVariable) {
+				TypeVariable typeVariable = (TypeVariable) variable;
+				if (this.generics.keySet().stream()
+						.noneMatch((candidate) -> getParameterName(candidate)
+								.equals(getParameterName(typeVariable)))) {
+					this.generics.put(typeVariable, resolution);
+				}
+			}
+		}
+
+		private String getParameterName(TypeVariable typeVariable) {
+			return typeVariable.asElement().getSimpleName().toString();
+		}
+
+	}
+
 }

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/ConfigurationMetadataAnnotationProcessorTests.java

 /*
- * Copyright 2012-2018 the original author or authors.
+ * Copyright 2012-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -45,6 +45,9 @@ import org.springframework.boot.configurationsample.endpoint.EnabledEndpoint;
 import org.springframework.boot.configurationsample.endpoint.SimpleEndpoint;
 import org.springframework.boot.configurationsample.endpoint.SpecificEndpoint;
 import org.springframework.boot.configurationsample.endpoint.incremental.IncrementalEndpoint;
+import org.springframework.boot.configurationsample.generic.AbstractGenericProperties;
+import org.springframework.boot.configurationsample.generic.SimpleGenericProperties;
+import org.springframework.boot.configurationsample.generic.UnresolvedGenericProperties;
 import org.springframework.boot.configurationsample.incremental.BarProperties;
 import org.springframework.boot.configurationsample.incremental.FooProperties;
 import org.springframework.boot.configurationsample.incremental.RenamedBarProperties;
@@ -292,7 +295,7 @@ public class ConfigurationMetadataAnnotationProcessorTests {
 		assertThat(metadata).has(Metadata.withProperty("collection.doubles",
 				"java.util.List<java.lang.Double>"));
 		assertThat(metadata).has(Metadata.withProperty("collection.names-to-holders",
-				"java.util.Map<java.lang.String,org.springframework.boot.configurationsample.simple.SimpleCollectionProperties.Holder<java.lang.String>>"));
+				"java.util.Map<java.lang.String,org.springframework.boot.configurationsample.simple.SimpleCollectionProperties$Holder<java.lang.String>>"));
 	}
 
 	@Test
@@ -504,6 +507,40 @@ public class ConfigurationMetadataAnnotationProcessorTests {
 				.withMessageContaining("Compilation failed");
 	}
 
+	@Test
+	public void simpleGenericProperties() {
+		ConfigurationMetadata metadata = compile(AbstractGenericProperties.class,
+				SimpleGenericProperties.class);
+		assertThat(metadata).has(
+				Metadata.withGroup("generic").fromSource(SimpleGenericProperties.class));
+		assertThat(metadata).has(Metadata.withProperty("generic.name", String.class)
+				.fromSource(SimpleGenericProperties.class)
+				.withDescription("Generic name.").withDefaultValue(null));
+		assertThat(metadata).has(Metadata
+				.withProperty("generic.mappings",
+						"java.util.Map<java.lang.Integer,java.time.Duration>")
+				.fromSource(SimpleGenericProperties.class)
+				.withDescription("Generic mappings.").withDefaultValue(null));
+		assertThat(metadata.getItems()).hasSize(3);
+	}
+
+	@Test
+	public void unresolvedGenericProperties() {
+		ConfigurationMetadata metadata = compile(AbstractGenericProperties.class,
+				UnresolvedGenericProperties.class);
+		assertThat(metadata).has(Metadata.withGroup("generic")
+				.fromSource(UnresolvedGenericProperties.class));
+		assertThat(metadata).has(Metadata.withProperty("generic.name", String.class)
+				.fromSource(UnresolvedGenericProperties.class)
+				.withDescription("Generic name.").withDefaultValue(null));
+		assertThat(metadata).has(Metadata
+				.withProperty("generic.mappings",
+						"java.util.Map<java.lang.Number,java.lang.Object>")
+				.fromSource(UnresolvedGenericProperties.class)
+				.withDescription("Generic mappings.").withDefaultValue(null));
+		assertThat(metadata.getItems()).hasSize(3);
+	}
+
 	@Test
 	public void genericTypes() {
 		ConfigurationMetadata metadata = compile(GenericConfig.class);
@@ -518,7 +555,7 @@ public class ConfigurationMetadataAnnotationProcessorTests {
 		assertThat(metadata).has(Metadata.withProperty("generic.foo.name")
 				.ofType(String.class).fromSource(GenericConfig.Foo.class));
 		assertThat(metadata).has(Metadata.withProperty("generic.foo.string-to-bar")
-				.ofType("java.util.Map<java.lang.String,org.springframework.boot.configurationsample.specific.GenericConfig.Bar<java.lang.Integer>>")
+				.ofType("java.util.Map<java.lang.String,org.springframework.boot.configurationsample.specific.GenericConfig$Bar<java.lang.Integer>>")
 				.fromSource(GenericConfig.Foo.class));
 		assertThat(metadata).has(Metadata.withProperty("generic.foo.string-to-integer")
 				.ofType("java.util.Map<java.lang.String,java.lang.Integer>")

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/TypeUtilsTests.java

+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.configurationprocessor;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.Set;
+import java.util.function.BiConsumer;
+
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.annotation.processing.SupportedSourceVersion;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import org.springframework.boot.configurationprocessor.TypeUtils.TypeDescriptor;
+import org.springframework.boot.configurationsample.generic.AbstractGenericProperties;
+import org.springframework.boot.configurationsample.generic.AbstractIntermediateGenericProperties;
+import org.springframework.boot.configurationsample.generic.SimpleGenericProperties;
+import org.springframework.boot.testsupport.compiler.TestCompiler;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link TypeUtils}.
+ *
+ * @author Stephane Nicoll
+ */
+public class TypeUtilsTests {
+
+	@Rule
+	public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+	@Test
+	public void resolveTypeDescriptorOnConcreteClass() throws IOException {
+		process(SimpleGenericProperties.class, (roundEnv, typeUtils) -> {
+			for (Element rootElement : roundEnv.getRootElements()) {
+				TypeDescriptor typeDescriptor = typeUtils
+						.resolveTypeDescriptor((TypeElement) rootElement);
+				assertThat(typeDescriptor.getGenerics().keySet().stream()
+						.map(Object::toString)).containsOnly("A", "B", "C");
+				assertThat(typeDescriptor.resolveGeneric("A"))
+						.hasToString(String.class.getName());
+				assertThat(typeDescriptor.resolveGeneric("B"))
+						.hasToString(Integer.class.getName());
+				assertThat(typeDescriptor.resolveGeneric("C"))
+						.hasToString(Duration.class.getName());
+			}
+		});
+	}
+
+	@Test
+	public void resolveTypeDescriptorOnIntermediateClass() throws IOException {
+		process(AbstractIntermediateGenericProperties.class, (roundEnv, typeUtils) -> {
+			for (Element rootElement : roundEnv.getRootElements()) {
+				TypeDescriptor typeDescriptor = typeUtils
+						.resolveTypeDescriptor((TypeElement) rootElement);
+				assertThat(typeDescriptor.getGenerics().keySet().stream()
+						.map(Object::toString)).containsOnly("A", "B", "C");
+				assertThat(typeDescriptor.resolveGeneric("A"))
+						.hasToString(String.class.getName());
+				assertThat(typeDescriptor.resolveGeneric("B"))
+						.hasToString(Integer.class.getName());
+				assertThat(typeDescriptor.resolveGeneric("C")).hasToString("C");
+			}
+		});
+	}
+
+	@Test
+	public void resolveTypeDescriptorWithOnlyGenerics() throws IOException {
+		process(AbstractGenericProperties.class, (roundEnv, typeUtils) -> {
+			for (Element rootElement : roundEnv.getRootElements()) {
+				TypeDescriptor typeDescriptor = typeUtils
+						.resolveTypeDescriptor((TypeElement) rootElement);
+				assertThat(typeDescriptor.getGenerics().keySet().stream()
+						.map(Object::toString)).containsOnly("A", "B", "C");
+
+			}
+		});
+	}
+
+	private void process(Class<?> target,
+			BiConsumer<RoundEnvironment, TypeUtils> consumer) throws IOException {
+		TestProcessor processor = new TestProcessor(consumer);
+		TestCompiler compiler = new TestCompiler(this.temporaryFolder);
+		compiler.getTask(target).call(processor);
+	}
+
+	@SupportedAnnotationTypes("*")
+	@SupportedSourceVersion(SourceVersion.RELEASE_8)
+	private final class TestProcessor extends AbstractProcessor {
+
+		private final BiConsumer<RoundEnvironment, TypeUtils> typeUtilsConsumer;
+
+		private TypeUtils typeUtils;
+
+		private TestProcessor(BiConsumer<RoundEnvironment, TypeUtils> typeUtils) {
+			this.typeUtilsConsumer = typeUtils;
+		}
+
+		@Override
+		public synchronized void init(ProcessingEnvironment env) {
+			this.typeUtils = new TypeUtils(env);
+		}
+
+		@Override
+		public boolean process(Set<? extends TypeElement> annotations,
+				RoundEnvironment roundEnv) {
+			this.typeUtilsConsumer.accept(roundEnv, this.typeUtils);
+			return false;
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationsample/generic/AbstractGenericProperties.java

+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.configurationsample.generic;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A base properties class with generics.
+ *
+ * @author Stephane Nicoll
+ */
+public class AbstractGenericProperties<A, B, C> {
+
+	/**
+	 * Generic name.
+	 */
+	private A name;
+
+	/**
+	 * Generic mappings.
+	 */
+	private final Map<B, C> mappings = new HashMap<>();
+
+	public A getName() {
+		return this.name;
+	}
+
+	public void setName(A name) {
+		this.name = name;
+	}
+
+	public Map<B, C> getMappings() {
+		return this.mappings;
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationsample/generic/AbstractIntermediateGenericProperties.java

+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.configurationsample.generic;
+
+/**
+ * An intermediate layer that resolves some of the generics from the parent but not all.
+ *
+ * @author Stephane Nicoll
+ */
+public abstract class AbstractIntermediateGenericProperties<C>
+		extends AbstractGenericProperties<String, Integer, C> {
+
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationsample/generic/SimpleGenericProperties.java

+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.configurationsample.generic;
+
+import java.time.Duration;
+
+import org.springframework.boot.configurationsample.ConfigurationProperties;
+
+/**
+ * Simple properties with resolved generic information.
+ *
+ * @author Stephane Nicoll
+ */
+@ConfigurationProperties("generic")
+public class SimpleGenericProperties
+		extends AbstractIntermediateGenericProperties<Duration> {
+
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationsample/generic/UnresolvedGenericProperties.java

+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.configurationsample.generic;
+
+import org.springframework.boot.configurationsample.ConfigurationProperties;
+
+/**
+ * Properties with unresolved generic information.
+ *
+ * @author Stephane Nicoll
+ */
+@ConfigurationProperties("generic")
+public class UnresolvedGenericProperties<B extends Number, C>
+		extends AbstractGenericProperties<String, B, C> {
+
+}