model: refactor ReferenceType

java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserMethodDeclaration.java

@@ -196,13 +196,7 @@ private Type replaceTypeParams(Type type, TypeSolver typeSolver, Context context
         }
 
         if (type.isReferenceType()) {
-            for (int i = 0; i < type.asReferenceType().typeParametersValues().size(); i++) {
-                Type replaced = replaceTypeParams(type.asReferenceType().typeParametersValues().get(i), typeSolver, context);
-                // Identity comparison on purpose
-                if (replaced != type.asReferenceType().typeParametersValues().get(i)) {
-                    type = type.asReferenceType().replaceParam(i, replaced);
-                }
-            }
+            type.asReferenceType().transformTypeParameters(tp -> replaceTypeParams(tp, typeSolver, context));
         }
 
         return type;

java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistClassDeclaration.java

@@ -150,9 +150,8 @@ public Optional<MethodUsage> solveMethodAsUsage(String name, List<Type> argument
                         SignatureAttribute.MethodSignature classSignature = SignatureAttribute.toMethodSignature(method.getGenericSignature());
                         List<Type> parametersOfReturnType = parseTypeParameters(classSignature.getReturnType().toString(), typeSolver, new JavassistMethodContext(method), invokationContext);
                         Type newReturnType = methodUsage.returnType();
-                        for (int i = 0; i < parametersOfReturnType.size(); i++) {
-                            newReturnType = newReturnType.asReferenceType().replaceParam(i, parametersOfReturnType.get(i));
-                        }
+                        // consume one parametersOfReturnType at the time
+                        newReturnType = newReturnType.asReferenceType().transformTypeParameters(tp -> parametersOfReturnType.remove(0));
                         methodUsage = methodUsage.replaceReturnType(newReturnType);
                     }
                     return Optional.of(methodUsage);

java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/resolution/MethodResolutionLogic.java

@@ -227,11 +227,7 @@ public static Type replaceTypeParam(Type type, TypeParameterDeclaration tp, Type
             return new ArrayType(replaceTypeParam(type.asArrayType().getComponentType(), tp, typeSolver));
         } else if (type.isReferenceType()) {
             ReferenceType result = type.asReferenceType();
-            int i = 0;
-            for (Type typeParam : result.typeParametersValues()) {
-                result = result.replaceParam(i, replaceTypeParam(typeParam, tp, typeSolver)).asReferenceType();
-                i++;
-            }
+            result = result.transformTypeParameters(typeParam -> replaceTypeParam(typeParam, tp, typeSolver)).asReferenceType();
             return result;
         } else if (type.isWildcard()) {
             if (type.describe().equals(tp.getName())) {

java-symbol-solver-model/src/main/java/com/github/javaparser/symbolsolver/model/usages/TypeTransformer.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2016 Federico Tomassetti
+ *
+ * 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 com.github.javaparser.symbolsolver.model.usages;
+
+import com.github.javaparser.symbolsolver.model.usages.typesystem.Type;
+
+/**
+ * Created by federico on 22/10/16.
+ */
+@FunctionalInterface
+public interface TypeTransformer {
+    Type transform(Type type);
+}

java-symbol-solver-model/src/main/java/com/github/javaparser/symbolsolver/model/usages/typesystem/ReferenceType.java

@@ -22,6 +22,7 @@
 import com.github.javaparser.symbolsolver.model.usages.MethodUsage;
 import com.github.javaparser.symbolsolver.model.usages.TypeParametersMap;
 import com.github.javaparser.symbolsolver.model.usages.TypeParametrized;
+import com.github.javaparser.symbolsolver.model.usages.TypeTransformer;
 import javaslang.Tuple2;
 
 import java.util.ArrayList;
@@ -152,16 +153,15 @@ public String describe() {
     /// TypeParameters
     ///
 
-    @FunctionalInterface
-    public interface TypeParameterTransformer {
-        Type transform(Type type);
-    }
-
-    public Type transformTypeParameters(TypeParameterTransformer transformer) {
+    public Type transformTypeParameters(TypeTransformer transformer) {
         Type result = this;
         int i = 0;
         for (Type tp : this.typeParametersValues()) {
-            result = result.asReferenceType().replaceParam(i, transformer.transform(tp));
+            Type transformedTp = transformer.transform(tp);
+            // Identity comparison on purpose
+            if (transformedTp != tp) {
+                result = result.asReferenceType().replaceParam(i, transformedTp);
+            }
             i++;
         }
         return result;