Refactored type variable erasure.

byte-buddy-dep/pom.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
@@ -54,6 +55,12 @@
             <version>${project.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.elasticsearch</groupId>
+            <artifactId>elasticsearch</artifactId>
+            <version>1.7.4</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>

byte-buddy-dep/src/main/java/net/bytebuddy/description/TypeVariableSource.java

@@ -61,7 +61,7 @@ interface Visitor<T> {
          * @param methodDescription The method onto which this visitor is applied.
          * @return The visitor's return value.
          */
-        T onMethod(MethodDescription methodDescription);
+        T onMethod(MethodDescription.InDefinedShape methodDescription);
 
         /**
          * A none-operational implementation of a type variable visitor that simply returns the visited source.
@@ -79,7 +79,7 @@ public TypeVariableSource onType(TypeDescription typeDescription) {
             }
 
             @Override
-            public TypeVariableSource onMethod(MethodDescription methodDescription) {
+            public TypeVariableSource onMethod(MethodDescription.InDefinedShape methodDescription) {
                 return methodDescription;
             }
 

byte-buddy-dep/src/main/java/net/bytebuddy/description/method/MethodDescription.java

@@ -568,7 +568,7 @@ public TypeDescription.Generic findVariable(String symbol) {
 
         @Override
         public <T> T accept(TypeVariableSource.Visitor<T> visitor) {
-            return visitor.onMethod(this);
+            return visitor.onMethod(this.asDefined()); // TODO!
         }
 
         @Override
@@ -1154,22 +1154,22 @@ public TypeSubstituting(TypeDescription.Generic declaringType,
 
         @Override
         public TypeList.Generic getTypeVariables() {
-            return new TypeList.Generic.ForDetachedTypes(methodDescription.getTypeVariables(), new VariableRetainingDelegator());
+            return new TypeList.Generic.ForDetachedTypes(methodDescription.getTypeVariables(), visitor);
         }
 
         @Override
         public TypeDescription.Generic getReturnType() {
-            return methodDescription.getReturnType().accept(new VariableRetainingDelegator());
+            return methodDescription.getReturnType().accept(visitor);
         }
 
         @Override
         public ParameterList<ParameterDescription.InGenericShape> getParameters() {
-            return new ParameterList.TypeSubstituting(this, methodDescription.getParameters(), new VariableRetainingDelegator());
+            return new ParameterList.TypeSubstituting(this, methodDescription.getParameters(), visitor);
         }
 
         @Override
         public TypeList.Generic getExceptionTypes() {
-            return new TypeList.Generic.ForDetachedTypes(methodDescription.getExceptionTypes(), new VariableRetainingDelegator());
+            return new TypeList.Generic.ForDetachedTypes(methodDescription.getExceptionTypes(), visitor);
         }
 
         @Override
@@ -1201,121 +1201,6 @@ public String getInternalName() {
         public InDefinedShape asDefined() {
             return methodDescription.asDefined();
         }
-
-        /**
-         * A visitor that only escalates to the actual visitor if a non-generic type is discovered or if a type variable
-         * that is not declared by the represented method is discovered. This way, a method's type variables are never bound
-         * by the supplied visitor as non-generic types never reference a method's type variables and since a type variable
-         * that is not declared by the represented method can never reference a type variable of the represented method.
-         */
-        protected class VariableRetainingDelegator extends TypeDescription.Generic.Visitor.Substitutor {
-
-            @Override
-            public TypeDescription.Generic onParameterizedType(TypeDescription.Generic parameterizedType) {
-                List<TypeDescription.Generic> parameters = new ArrayList<TypeDescription.Generic>(parameterizedType.getTypeArguments().size());
-                for (TypeDescription.Generic parameter : parameterizedType.getTypeArguments()) {
-                    if (parameter.getSort().isTypeVariable() && !methodDescription.getTypeVariables().contains(parameter)) {
-                        return visitor.onParameterizedType(parameterizedType);
-                    } else if (parameter.getSort().isWildcard()) {
-                        TypeList.Generic bounds = parameter.getLowerBounds();
-                        bounds = bounds.isEmpty() ? parameter.getUpperBounds() : bounds;
-                        if (bounds.getOnly().getSort().isTypeVariable() && !methodDescription.getTypeVariables().contains(parameter)) {
-                            return visitor.onParameterizedType(parameterizedType);
-                        }
-                    }
-                    parameters.add(parameter.accept(this));
-                }
-                TypeDescription.Generic ownerType = parameterizedType.getOwnerType();
-                return new TypeDescription.Generic.OfParameterizedType.Latent(parameterizedType.asErasure(),
-                        ownerType == null
-                                ? TypeDescription.Generic.UNDEFINED
-                                : ownerType.accept(this),
-                        parameters,
-                        parameterizedType.getDeclaredAnnotations());
-            }
-
-            @Override
-            public TypeDescription.Generic onNonGenericType(TypeDescription.Generic typeDescription) {
-                return visitor.onNonGenericType(typeDescription);
-            }
-
-            @Override
-            protected TypeDescription.Generic onSimpleType(TypeDescription.Generic typeDescription) {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public TypeDescription.Generic onTypeVariable(TypeDescription.Generic typeVariable) {
-                return methodDescription.getTypeVariables().contains(typeVariable)
-                        ? new RetainedVariable(typeVariable)
-                        : visitor.onTypeVariable(typeVariable);
-            }
-
-            @Override
-            public int hashCode() {
-                return TypeSubstituting.this.hashCode();
-            }
-
-            @Override
-            public boolean equals(Object other) {
-                return other != null && other.getClass() == this.getClass()
-                        && TypeSubstituting.this.equals(((VariableRetainingDelegator) other).getOuter());
-            }
-
-            /**
-             * Returns the outer instance.
-             *
-             * @return The outer instance.
-             */
-            private Object getOuter() {
-                return TypeSubstituting.this;
-            }
-
-            @Override
-            public String toString() {
-                return "MethodDescription.TypeSubstituting.VariableRetainingDelegator{methodDescription=" + TypeSubstituting.this + '}';
-            }
-
-            /**
-             * A retained type variable that is declared by the method.
-             */
-            protected class RetainedVariable extends TypeDescription.Generic.OfTypeVariable {
-
-                /**
-                 * The type variable this retained variable represents.
-                 */
-                private final TypeDescription.Generic typeVariable;
-
-                /**
-                 * Creates a new retained type variable.
-                 *
-                 * @param typeVariable The type variable this retained variable represents.
-                 */
-                protected RetainedVariable(TypeDescription.Generic typeVariable) {
-                    this.typeVariable = typeVariable;
-                }
-
-                @Override
-                public TypeList.Generic getUpperBounds() {
-                    return new TypeList.Generic.ForDetachedTypes(typeVariable.getUpperBounds(), VariableRetainingDelegator.this);
-                }
-
-                @Override
-                public TypeVariableSource getVariableSource() {
-                    return TypeSubstituting.this;
-                }
-
-                @Override
-                public String getSymbol() {
-                    return typeVariable.getSymbol();
-                }
-
-                @Override
-                public AnnotationList getDeclaredAnnotations() {
-                    return typeVariable.getDeclaredAnnotations();
-                }
-            }
-        }
     }
 
     /**

byte-buddy-dep/src/main/java/net/bytebuddy/description/type/TypeDescription.java

@@ -688,12 +688,12 @@ public Generic onParameterizedType(Generic parameterizedType) {
 
                 @Override
                 public Generic onTypeVariable(Generic typeVariable) {
-                    return new OfNonGenericType.Latent(typeVariable.asErasure(), typeVariable.getDeclaredAnnotations());
+                    return typeVariable.getVariableSource().accept(new TypeVariableReviser(typeVariable));
                 }
 
                 @Override
                 public Generic onNonGenericType(Generic typeDescription) {
-                    return new OfNonGenericType.Latent(typeDescription.asErasure(), typeDescription.getDeclaredAnnotations());
+                    return new OfNonGenericType.Latent(typeDescription.asErasure(), typeDescription.getDeclaredAnnotations()); // TODO: Retain old value?
                 }
 
                 @Override
@@ -746,6 +746,54 @@ public String toString() {
                         return "TypeDescription.Generic.Visitor.TypeVariableErasing.PartialErasureReviser." + name();
                     }
                 }
+
+                protected static class TypeVariableReviser implements TypeVariableSource.Visitor<Generic> {
+
+                    private final Generic typeVariable;
+
+                    protected TypeVariableReviser(Generic typeVariable) {
+                        this.typeVariable = typeVariable;
+                    }
+
+                    @Override
+                    public Generic onType(TypeDescription typeDescription) {
+                        return new OfNonGenericType.Latent(typeVariable.asErasure(), typeVariable.getDeclaredAnnotations());
+                    }
+
+                    @Override
+                    public Generic onMethod(MethodDescription.InDefinedShape methodDescription) {
+                        return new RetainedTypeVariable(typeVariable);
+                    }
+                }
+
+                protected static class RetainedTypeVariable extends OfTypeVariable {
+
+                    private final Generic typeVariable;
+
+                    protected RetainedTypeVariable(Generic typeVariable) {
+                        this.typeVariable = typeVariable;
+                    }
+
+                    @Override
+                    public TypeList.Generic getUpperBounds() {
+                        return typeVariable.getUpperBounds().accept(TypeVariableErasing.INSTANCE);
+                    }
+
+                    @Override
+                    public TypeVariableSource getVariableSource() {
+                        return typeVariable.getVariableSource();
+                    }
+
+                    @Override
+                    public String getSymbol() {
+                        return typeVariable.getSymbol();
+                    }
+
+                    @Override
+                    public AnnotationList getDeclaredAnnotations() {
+                        return typeVariable.getDeclaredAnnotations();
+                    }
+                }
             }
 
             /**
@@ -2051,12 +2099,7 @@ public static Visitor<Generic> bind(Generic typeDescription) {
 
                     @Override
                     public Generic onTypeVariable(Generic typeVariable) {
-                        Generic substitution = bindings.get(typeVariable);
-                        if (substitution == null) {
-                            throw new IllegalStateException("Unknown type variable: " + typeVariable);
-                        } else {
-                            return substitution;
-                        }
+                        return typeVariable.getVariableSource().accept(new TypeVariableSubstitutor(typeVariable));
                     }
 
                     @Override
@@ -2088,6 +2131,59 @@ public String toString() {
                                 "bindings=" + bindings +
                                 '}';
                     }
+
+                    protected class TypeVariableSubstitutor implements TypeVariableSource.Visitor<Generic> {
+
+                        private final Generic typeVariable;
+
+                        protected TypeVariableSubstitutor(Generic typeVariable) {
+                            this.typeVariable = typeVariable;
+                        }
+
+                        @Override
+                        public Generic onType(TypeDescription typeDescription) {
+                            Generic substitution = bindings.get(typeVariable);
+                            if (substitution == null) {
+                                throw new IllegalStateException("Unknown type variable: " + typeVariable);
+                            } else {
+                                return substitution;
+                            }
+                        }
+
+                        @Override
+                        public Generic onMethod(MethodDescription.InDefinedShape methodDescription) {
+                            return new RetainedMethodTypeVariable(typeVariable);
+                        }
+                    }
+
+                    protected class RetainedMethodTypeVariable extends OfTypeVariable {
+
+                        private final Generic typeVariable;
+
+                        protected RetainedMethodTypeVariable(Generic typeVariable) {
+                            this.typeVariable = typeVariable;
+                        }
+
+                        @Override
+                        public TypeList.Generic getUpperBounds() {
+                            return typeVariable.getUpperBounds().accept(ForTypeVariableBinding.this);
+                        }
+
+                        @Override
+                        public TypeVariableSource getVariableSource() {
+                            return typeVariable.getVariableSource();
+                        }
+
+                        @Override
+                        public String getSymbol() {
+                            return typeVariable.getSymbol();
+                        }
+
+                        @Override
+                        public AnnotationList getDeclaredAnnotations() {
+                            return typeVariable.getDeclaredAnnotations();
+                        }
+                    }
                 }
 
                 /**

byte-buddy-dep/src/test/java/net/bytebuddy/Foo.java

@@ -0,0 +1,31 @@
+package net.bytebuddy;
+
+import net.bytebuddy.implementation.StubMethod;
+import org.elasticsearch.client.Client;
+import org.junit.Test;
+
+import java.util.concurrent.Callable;
+
+import static net.bytebuddy.matcher.ElementMatchers.any;
+
+public class Foo {
+
+    @Test
+    public void testFoo() throws Exception {
+        new ByteBuddy().subclass(Client.class).method(any()).intercept(StubMethod.INSTANCE).make();
+    }
+
+    @Test
+    public void testBar() throws Exception {
+        new ByteBuddy().subclass(Qux.class).method(any()).intercept(StubMethod.INSTANCE).make();
+    }
+
+    interface Bar<T> {
+
+        <S> void bar(Callable<S> arg);
+    }
+
+    interface Qux extends Bar<Void> {
+
+    }
+}

byte-buddy-dep/src/test/java/net/bytebuddy/description/TypeVariableSourceVisitorNoOpTest.java

@@ -20,7 +20,7 @@ public void testVisitType() throws Exception {
 
     @Test
     public void testVisitMethod() throws Exception {
-        MethodDescription methodDescription = mock(MethodDescription.class);
+        MethodDescription.InDefinedShape methodDescription = mock(MethodDescription.InDefinedShape.class);
         assertThat(TypeVariableSource.Visitor.NoOp.INSTANCE.onMethod(methodDescription), is((TypeVariableSource) methodDescription));
     }