add codes for tricky parameters

build.gradle

@@ -110,3 +110,9 @@ javadoc {
         options.addBooleanOption('html5', true)
     }
 }
+
+test {
+    testLogging {
+        showStandardStreams = true
+    }
+}

src/main/java/org/checkerframework/specimin/SpeciminRunner.java

@@ -26,6 +26,8 @@
 import joptsimple.OptionParser;
 import joptsimple.OptionSet;
 import joptsimple.OptionSpec;
+import org.checkerframework.checker.signature.qual.ClassGetSimpleName;
+import org.checkerframework.checker.signature.qual.FullyQualifiedName;
 
 /** This class is the main runner for Specimin. Use its main() method to start Specimin. */
 public class SpeciminRunner {
@@ -165,7 +167,9 @@ public static void performMinimization(
     // correct the types of all related files before adding them to parsedTargetFiles
     JavaTypeCorrect typeCorrecter = new JavaTypeCorrect(root, relatedClass);
     typeCorrecter.correctTypesForAllFiles();
-    addMissingClass.updateTypes(typeCorrecter.getTypeToChange());
+    Map<@ClassGetSimpleName String, @ClassGetSimpleName String> typesToChange =
+        typeCorrecter.getTypeToChange();
+    addMissingClass.updateTypes(typesToChange);
 
     for (String directory : relatedClass) {
       // directories already in parsedTargetFiles are original files in the root directory, we are
@@ -186,8 +190,16 @@ public static void performMinimization(
       // the target methods, do not output it.
       if (isEmptyCompilationUnit(target.getValue())) {
         // target key will have this form: "path/of/package/ClassName.java"
-        String classFullyQualfiedName = target.getKey().replace("/", ".");
-        classFullyQualfiedName = classFullyQualfiedName.replace(".java", "");
+        String classFullyQualfiedName = getFullyQualifiedClassName(target.getKey());
+        @SuppressWarnings("signature") // since it's the last element of a fully qualified path
+        @ClassGetSimpleName String simpleName =
+            classFullyQualfiedName.substring(classFullyQualfiedName.lastIndexOf(".") + 1);
+        // If this condition is true, this class is a synthetic class initially created to be a
+        // return type of some synthetic methods, but later javac has found the correct return type
+        // for that method.
+        if (typesToChange.containsKey(simpleName)) {
+          continue;
+        }
         if (!finder.getUsedClass().contains(classFullyQualfiedName)) {
           continue;
         }
@@ -216,6 +228,24 @@ public static void performMinimization(
     deleteFiles(createdClass);
   }
 
+  /**
+   * Converts a path to a Java file into the fully-qualified name of the public class in that file,
+   * relying on the file's relative path being the same as the package name.
+   *
+   * @param javaFilePath the path to a .java file, in this form: "path/of/package/ClassName.java".
+   *     Note that this path must be rooted at the same directory in which javac could be invoked to
+   *     compile the file
+   * @return the fully-qualified name of the given class
+   */
+  @SuppressWarnings("signature") // string manipulation
+  private static @FullyQualifiedName String getFullyQualifiedClassName(final String javaFilePath) {
+    String result = javaFilePath.replace("/", ".");
+    if (!result.endsWith(".java")) {
+      throw new RuntimeException("A Java file path does not end with .java: " + result);
+    }
+    return result.substring(0, result.length() - 5);
+  }
+
   /**
    * Checks whether the given compilation unit contains nothing. Should conservatively return false
    * by default if unsure.

src/main/java/org/checkerframework/specimin/TargetMethodFinderVisitor.java

@@ -4,6 +4,7 @@
 import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
 import com.github.javaparser.ast.body.ConstructorDeclaration;
 import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.body.Parameter;
 import com.github.javaparser.ast.body.VariableDeclarator;
 import com.github.javaparser.ast.expr.Expression;
 import com.github.javaparser.ast.expr.FieldAccessExpr;
@@ -198,15 +199,43 @@ public Visitable visit(MethodDeclaration method, Void p) {
       Type returnType = method.getType();
       // JavaParser may misinterpret unresolved array types as reference types.
       // To ensure accuracy, we resolve the type before proceeding with the check.
-      if (returnType.resolve() instanceof ResolvedReferenceType) {
-        usedClass.add(returnType.resolve().asReferenceType().getQualifiedName());
+      try {
+        ResolvedType resolvedType = returnType.resolve();
+        if (resolvedType instanceof ResolvedReferenceType) {
+          usedClass.add(resolvedType.asReferenceType().getQualifiedName());
+        }
+      } catch (UnsupportedOperationException e) {
+        // Occurs if the type is a type variable, so there is nothing to do.
+        // The type variable will be resolved later, by the UnsolvedSymbolVisitor.
       }
     }
     Visitable result = super.visit(method, p);
     insideTargetMethod = false;
     return result;
   }
 
+  @Override
+  public Visitable visit(Parameter para, Void p) {
+    if (insideTargetMethod) {
+      ResolvedType paraType = para.resolve().getType();
+      if (paraType.isReferenceType()) {
+        String paraTypeFullName =
+            paraType.asReferenceType().getTypeDeclaration().get().getQualifiedName();
+        usedClass.add(paraTypeFullName);
+        for (ResolvedType typeParameterValue : paraType.asReferenceType().typeParametersValues()) {
+          String typeParameterValueName = typeParameterValue.describe();
+          if (typeParameterValueName.contains("<")) {
+            // removing the "<...>" part if there is any.
+            typeParameterValueName =
+                typeParameterValueName.substring(0, typeParameterValueName.indexOf("<"));
+          }
+          usedClass.add(typeParameterValueName);
+        }
+      }
+    }
+    return super.visit(para, p);
+  }
+
   @Override
   public Visitable visit(MethodCallExpr call, Void p) {
     if (insideTargetMethod) {

src/main/java/org/checkerframework/specimin/UnsolvedClass.java

@@ -27,6 +27,9 @@ public class UnsolvedClass {
    */
   private final String packageName;
 
+  /** This field records the number of type variables for this class */
+  private int numberOfTypeVariables = 0;
+
   /**
    * Create an instance of UnsolvedClass
    *
@@ -95,6 +98,20 @@ public void addFields(String variableExpression) {
     this.classFields.add(variableExpression);
   }
 
+  /** This method sets the number of type variables for the current class */
+  public void setNumberOfTypeVariables(int numberOfTypeVariables) {
+    this.numberOfTypeVariables = numberOfTypeVariables;
+  }
+
+  /**
+   * This method tells the number of type variables for this class
+   *
+   * @return the number of type variables
+   */
+  public int getNumberOfTypeVariables() {
+    return this.numberOfTypeVariables;
+  }
+
   /**
    * Update the return type of a method. Note: this method is supposed to be used to update
    * synthetic methods, where the return type of each method is distinct.
@@ -149,7 +166,7 @@ public void updateFieldByType(String currentType, String correctType) {
   public String toString() {
     StringBuilder sb = new StringBuilder();
     sb.append("package ").append(packageName).append(";\n");
-    sb.append("public class ").append(className).append(" {\n");
+    sb.append("public class ").append(className).append(getTypeVariablesAsString()).append(" {\n");
     for (String variableDeclarations : classFields) {
       sb.append("    " + "public " + variableDeclarations + ";\n");
     }
@@ -159,4 +176,25 @@ public String toString() {
     sb.append("}\n");
     return sb.toString();
   }
+
+  /**
+   * Return a synthetic representation for type variables of the current class.
+   *
+   * @return the synthetic representation for type variables
+   */
+  public String getTypeVariablesAsString() {
+    if (numberOfTypeVariables == 0) {
+      return "";
+    }
+    StringBuilder result = new StringBuilder();
+    // if class A has three type variables, the expression will be A<T, T1, T2>
+    result.append("<");
+    for (int i = 0; i < numberOfTypeVariables; i++) {
+      String typeExpression = "T" + ((i > 0) ? i : "");
+      result.append(typeExpression).append(", ");
+    }
+    result.delete(result.length() - 2, result.length());
+    result.append(">");
+    return result.toString();
+  }
 }