Support for ResolvableType.getType().getTypeName() on Java 8

Issue: SPR-16535

(cherry picked from commit 6663d0f)

Author: jhoeller

spring-core/src/main/java/org/springframework/core/ResolvableType.java

@@ -34,6 +34,7 @@
 import org.springframework.core.SerializableTypeWrapper.FieldTypeProvider;
 import org.springframework.core.SerializableTypeWrapper.MethodParameterTypeProvider;
 import org.springframework.core.SerializableTypeWrapper.TypeProvider;
+import org.springframework.lang.UsesJava8;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.ConcurrentReferenceHashMap;
@@ -1454,6 +1455,23 @@ public SyntheticParameterizedType(Type rawType, Type[] typeArguments) {
 			this.typeArguments = typeArguments;
 		}
 
+		@Override  // on Java 8
+		@UsesJava8
+		public String getTypeName() {
+			StringBuilder result = new StringBuilder(this.rawType.getTypeName());
+			if (this.typeArguments.length > 0) {
+				result.append('<');
+				for (int i = 0; i < this.typeArguments.length; i++) {
+					if (i > 0) {
+						result.append(", ");
+					}
+					result.append(this.typeArguments[i].getTypeName());
+				}
+				result.append('>');
+			}
+			return result.toString();
+		}
+
 		@Override
 		public Type getOwnerType() {
 			return null;

spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2018 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.
@@ -42,7 +42,6 @@
 import java.util.TreeSet;
 import java.util.concurrent.Callable;
 
-import org.hamcrest.Matchers;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -927,16 +926,6 @@ public void getSource() throws Exception {
 		assertThat(ResolvableType.forClass(classType).getSuperType().getSource(), equalTo((Object) classType.getGenericSuperclass()));
 	}
 
-	private void assertFieldToStringValue(String field, String expected) throws Exception {
-		ResolvableType type = ResolvableType.forField(Fields.class.getField(field));
-		assertThat("field " + field + " toString", type.toString(), equalTo(expected));
-	}
-
-	private void assertTypedFieldToStringValue(String field, String expected) throws Exception {
-		ResolvableType type = ResolvableType.forField(Fields.class.getField(field), TypedFields.class);
-		assertThat("field " + field + " toString", type.toString(), equalTo(expected));
-	}
-
 	@Test
 	public void resolveFromOuterClass() throws Exception {
 		Field field = EnclosedInParameterizedType.InnerTyped.class.getField("field");
@@ -954,7 +943,6 @@ public void resolveFromClassWithGenerics() throws Exception {
 		assertThat(type.asCollection().getGeneric().getGeneric().resolve(), equalTo((Type) String.class));
 	}
 
-
 	@Test
 	public void isAssignableFromMustNotBeNull() throws Exception {
 		this.thrown.expect(IllegalArgumentException.class);
@@ -1189,25 +1177,25 @@ public void hashCodeAndEquals() throws Exception {
 		assertThat(forFieldDirect, not(equalTo(forFieldWithImplementation)));
 	}
 
-	@SuppressWarnings("unused")
-	private HashMap<Integer, List<String>> myMap;
-
 	@Test
 	public void javaDocSample() throws Exception {
 		ResolvableType t = ResolvableType.forField(getClass().getDeclaredField("myMap"));
+		assertThat(t.toString(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>"));
+		assertThat(t.getType().getTypeName(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>"));
 		assertThat(t.getSuperType().toString(), equalTo("java.util.AbstractMap<java.lang.Integer, java.util.List<java.lang.String>>"));
 		assertThat(t.asMap().toString(), equalTo("java.util.Map<java.lang.Integer, java.util.List<java.lang.String>>"));
-		assertThat(t.getGeneric(0).resolve(), equalTo((Class)Integer.class));
-		assertThat(t.getGeneric(1).resolve(), equalTo((Class)List.class));
+		assertThat(t.getGeneric(0).resolve(), equalTo(Integer.class));
+		assertThat(t.getGeneric(1).resolve(), equalTo(List.class));
 		assertThat(t.getGeneric(1).toString(), equalTo("java.util.List<java.lang.String>"));
-		assertThat(t.resolveGeneric(1, 0), equalTo((Class) String.class));
+		assertThat(t.resolveGeneric(1, 0), equalTo(String.class));
 	}
 
 	@Test
 	public void forClassWithGenerics() throws Exception {
 		ResolvableType elementType = ResolvableType.forClassWithGenerics(Map.class, Integer.class, String.class);
 		ResolvableType listType = ResolvableType.forClassWithGenerics(List.class, elementType);
 		assertThat(listType.toString(), equalTo("java.util.List<java.util.Map<java.lang.Integer, java.lang.String>>"));
+		assertThat(listType.getType().getTypeName(), equalTo("java.util.List<java.util.Map<java.lang.Integer, java.lang.String>>"));
 	}
 
 	@Test
@@ -1228,7 +1216,7 @@ public void forArrayComponent() throws Exception {
 		ResolvableType elementType = ResolvableType.forField(Fields.class.getField("stringList"));
 		ResolvableType type = ResolvableType.forArrayComponent(elementType);
 		assertThat(type.toString(), equalTo("java.util.List<java.lang.String>[]"));
-		assertThat(type.resolve(), equalTo((Class) List[].class));
+		assertThat(type.resolve(), equalTo(List[].class));
 	}
 
 	@Test
@@ -1248,14 +1236,14 @@ public void serialize() throws Exception {
 	@Test
 	public void canResolveVoid() throws Exception {
 		ResolvableType type = ResolvableType.forClass(void.class);
-		assertThat(type.resolve(), equalTo((Class) void.class));
+		assertThat(type.resolve(), equalTo(void.class));
 	}
 
 	@Test
 	public void narrow() throws Exception {
 		ResolvableType type = ResolvableType.forField(Fields.class.getField("stringList"));
 		ResolvableType narrow = ResolvableType.forType(ArrayList.class, type);
-		assertThat(narrow.getGeneric().resolve(), equalTo((Class) String.class));
+		assertThat(narrow.getGeneric().resolve(), equalTo(String.class));
 	}
 
 	@Test
@@ -1330,23 +1318,30 @@ private ResolvableType testSerialization(ResolvableType type) throws Exception {
 		ResolvableType read = (ResolvableType) ois.readObject();
 		assertThat(read, equalTo(type));
 		assertThat(read.getType(), equalTo(type.getType()));
-		assertThat(read.resolve(), equalTo((Class) type.resolve()));
+		assertThat(read.resolve(), equalTo(type.resolve()));
 		return read;
 	}
 
-	private static AssertAssignbleMatcher assertAssignable(final ResolvableType type, final ResolvableType... fromTypes) {
-		return new AssertAssignbleMatcher() {
-			@Override
-			public void equalTo(boolean... values) {
-				for (int i = 0; i < fromTypes.length; i++) {
-					assertThat(stringDesc(type) + " isAssignableFrom " + stringDesc(fromTypes[i]),
-							type.isAssignableFrom(fromTypes[i]), Matchers.equalTo(values[i]));
-				}
+	private void assertFieldToStringValue(String field, String expected) throws Exception {
+		ResolvableType type = ResolvableType.forField(Fields.class.getField(field));
+		assertThat("field " + field + " toString", type.toString(), equalTo(expected));
+	}
+
+	private void assertTypedFieldToStringValue(String field, String expected) throws Exception {
+		ResolvableType type = ResolvableType.forField(Fields.class.getField(field), TypedFields.class);
+		assertThat("field " + field + " toString", type.toString(), equalTo(expected));
+	}
+
+	private AssertAssignbleMatcher assertAssignable(final ResolvableType type, final ResolvableType... fromTypes) {
+		return values -> {
+			for (int i = 0; i < fromTypes.length; i++) {
+				assertThat(stringDesc(type) + " isAssignableFrom " + stringDesc(fromTypes[i]),
+						type.isAssignableFrom(fromTypes[i]), equalTo(values[i]));
 			}
 		};
 	}
 
-	private static String stringDesc(ResolvableType type) {
+	private String stringDesc(ResolvableType type) {
 		if (type == ResolvableType.NONE) {
 			return "NONE";
 		}
@@ -1357,7 +1352,11 @@ private static String stringDesc(ResolvableType type) {
 	}
 
 
-	private static interface AssertAssignbleMatcher {
+	@SuppressWarnings("unused")
+	private HashMap<Integer, List<String>> myMap;
+
+
+	private interface AssertAssignbleMatcher {
 
 		void equalTo(boolean... values);
 	}