add codes for tricky parameters

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

@@ -26,6 +26,7 @@
 import joptsimple.OptionParser;
 import joptsimple.OptionSet;
 import joptsimple.OptionSpec;
+import org.checkerframework.checker.signature.qual.ClassGetSimpleName;
 
 /** This class is the main runner for Specimin. Use its main() method to start Specimin. */
 public class SpeciminRunner {
@@ -165,7 +166,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
@@ -187,7 +190,21 @@ public static void performMinimization(
       if (isEmptyCompilationUnit(target.getValue())) {
         // target key will have this form: "path/of/package/ClassName.java"
         String classFullyQualfiedName = target.getKey().replace("/", ".");
-        classFullyQualfiedName = classFullyQualfiedName.replace(".java", "");
+        if (!classFullyQualfiedName.endsWith(".java")) {
+          throw new RuntimeException(
+              "A Java file directory does not end with .java: " + classFullyQualfiedName);
+        }
+        classFullyQualfiedName =
+            classFullyQualfiedName.substring(0, classFullyQualfiedName.length() - 5);
+        @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;
         }

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;
@@ -207,6 +208,28 @@ public Visitable visit(MethodDeclaration method, Void p) {
     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 typeVariable : paraType.asReferenceType().typeParametersValues()) {
+          String typeVariableFullName = typeVariable.describe();
+          if (typeVariableFullName.contains("<")) {
+            // removing the "<...>" part if there is any.
+            typeVariableFullName =
+                typeVariableFullName.substring(0, typeVariableFullName.indexOf("<"));
+          }
+          usedClass.add(typeVariableFullName);
+        }
+      }
+    }
+    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, TT, TTT>
+    result.append("<");
+    for (int i = 0; i < numberOfTypeVariables; i++) {
+      String typeExpression = "T" + "T".repeat(i);
+      result.append(typeExpression).append(", ");
+    }
+    result.delete(result.length() - 2, result.length());
+    result.append(">");
+    return result.toString();
+  }
 }

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

@@ -25,6 +25,7 @@
 import com.github.javaparser.ast.stmt.SwitchEntry;
 import com.github.javaparser.ast.stmt.TryStmt;
 import com.github.javaparser.ast.stmt.WhileStmt;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
 import com.github.javaparser.ast.type.PrimitiveType;
 import com.github.javaparser.ast.type.ReferenceType;
 import com.github.javaparser.ast.type.Type;
@@ -400,13 +401,43 @@ public Visitable visit(BlockStmt node, Void p) {
 
   @Override
   public Visitable visit(VariableDeclarator decl, Void p) {
+    // This part is to update the symbol table.
     boolean isAField =
         !decl.getParentNode().isEmpty() && (decl.getParentNode().get() instanceof FieldDeclaration);
     if (!isAField) {
       HashSet<String> currentListOfLocals = localVariables.removeFirst();
       currentListOfLocals.add(decl.getNameAsString());
       localVariables.addFirst(currentListOfLocals);
     }
+
+    // This part is to create synthetic class for the type of decl if needed.
+    Type declType = decl.getType();
+    try {
+      declType.resolve();
+    } catch (UnsolvedSymbolException | UnsupportedOperationException e) {
+      String typeAsString = declType.asString();
+      List<String> elements = Splitter.onPattern("\\.").splitToList(typeAsString);
+      // There could be two cases here: either a fully-qualified class name or a simple class name.
+      // This is the fully-qualified case.
+      if (elements.size() > 1) {
+        @SuppressWarnings("signature") // since this type is in a fully-qualfied form
+        @FullyQualifiedName String qualifiedTypeName = typeAsString;
+        updateMissingClass(getSimpleSyntheticClassFromFullyQualifiedName(qualifiedTypeName));
+      }
+      /**
+       * Handles the case where the type is a simple class name. Two sub-cases are considered: 1.
+       * The class is included among the import statements. 2. The class is not included in the
+       * import statements but is in the same directory as the input class. The first sub-case is
+       * addressed by the visit method for ImportDeclaration.
+       */
+      else if (!classAndPackageMap.containsKey(typeAsString)) {
+        @SuppressWarnings("signature") // since this is the simple name case
+        @ClassGetSimpleName String className = typeAsString;
+        String packageName = this.currentPackage;
+        UnsolvedClass newClass = new UnsolvedClass(className, packageName);
+        updateMissingClass(newClass);
+      }
+    }
     return super.visit(decl, p);
   }
 
@@ -493,7 +524,7 @@ public Visitable visit(MethodDeclaration node, Void arg) {
       }
     }
 
-    HashSet<String> currentLocalVariables = new HashSet<>();
+    HashSet<String> currentLocalVariables = getParameterFromAMethodDeclaration(node);
     localVariables.addFirst(currentLocalVariables);
     super.visit(node, arg);
     localVariables.removeFirst();
@@ -541,10 +572,63 @@ public Visitable visit(MethodCallExpr method, Void p) {
     return super.visit(method, p);
   }
 
+  @Override
+  public Visitable visit(ClassOrInterfaceType typeExpr, Void p) {
+    /**
+     * Workaround for a JavaParser bug: When a type is referenced as a class path, like
+     * com.example.Dog dog, JavaParser considers its package components (com and com.example) as
+     * types, too. This issue happens even when the source file of the Dog class is present in the
+     * codebase.
+     */
+    if (!isCapital(typeExpr.getName().asString())) {
+      return super.visit(typeExpr, p);
+    }
+    if (!typeExpr.isReferenceType()) {
+      return super.visit(typeExpr, p);
+    }
+    try {
+      typeExpr.getElementType().resolve().describe();
+      return super.visit(typeExpr, p);
+    }
+    /*
+     * If the class file is not in the codebase yet, we got UnsolvedSymbolException.
+     * If the class file is not in the codebase and used by an anonymous class, we got UnsupportedOperationException.
+     * If the class file is in the codebase but the type variables are missing, we got IllegalArgumentException.
+     */
+    catch (UnsolvedSymbolException | UnsupportedOperationException | IllegalArgumentException e) {
+      // This method only updates type variables for unsolved classes. Other problems causing a
+      // class to be unsolved will be fixed by other methods.
+      Optional<NodeList<Type>> typeArguments = typeExpr.getTypeArguments();
+      UnsolvedClass classToUpdate;
+      int numberOfArguments = 0;
+      String typeRawName = typeExpr.getElementType().asString();
+      if (typeArguments.isPresent()) {
+        numberOfArguments = typeArguments.get().size();
+        // without any type argument
+        typeRawName = typeRawName.substring(0, typeRawName.indexOf("<"));
+      }
+      if (isAClassPath(typeRawName)) {
+        String packageName = typeRawName.substring(0, typeRawName.lastIndexOf("."));
+        @SuppressWarnings("signature") // since this is the last element of a class path
+        @ClassGetSimpleName String className = typeRawName.substring(typeRawName.lastIndexOf(".") + 1);
+        classToUpdate = new UnsolvedClass(className, packageName);
+      } else {
+        @SuppressWarnings("signature") // since it is not in a fully qualifed format
+        @ClassGetSimpleName String className = typeRawName;
+        String packageName = classAndPackageMap.getOrDefault(className, currentPackage);
+        classToUpdate = new UnsolvedClass(className, packageName);
+      }
+      classToUpdate.setNumberOfTypeVariables(numberOfArguments);
+      updateMissingClass(classToUpdate);
+      gotException = true;
+    }
+    return super.visit(typeExpr, p);
+  }
+
   @Override
   public Visitable visit(Parameter parameter, Void p) {
     try {
-      parameter.resolve().describeType();
+      parameter.resolve();
       return super.visit(parameter, p);
     }
     // If the parameter originates from a Java built-in library, such as java.io or java.lang,
@@ -823,6 +907,21 @@ public static boolean isASuperCall(Expression node) {
     }
   }
 
+  /**
+   * Given a method declaration, this method will return the set of parameters of that method
+   * declaration.
+   *
+   * @param decl the method declaration
+   * @return the set of parameters of decl
+   */
+  public HashSet<String> getParameterFromAMethodDeclaration(MethodDeclaration decl) {
+    HashSet<String> setOfParameters = new HashSet<>();
+    for (Parameter parameter : decl.getParameters()) {
+      setOfParameters.add(parameter.getName().asString());
+    }
+    return setOfParameters;
+  }
+
   /**
    * For a super call, this method will update the corresponding synthetic class
    *
@@ -1110,6 +1209,9 @@ public void updateMissingClass(UnsolvedClass missedClass) {
         for (String variablesDescription : missedClass.getClassFields()) {
           e.addFields(variablesDescription);
         }
+        if (missedClass.getNumberOfTypeVariables() > 0) {
+          e.setNumberOfTypeVariables(missedClass.getNumberOfTypeVariables());
+        }
         return;
       }
     }
@@ -1136,9 +1238,10 @@ public void updateSyntheticSourceCode() {
    * @param missedClass a synthetic class to be deleted
    */
   public void deleteOldSyntheticClass(UnsolvedClass missedClass) {
-    String classPackage = classAndPackageMap.get(missedClass.getClassName());
+    String classPackage = missedClass.getPackageName();
+    String classDirectory = classPackage.replace(".", "/");
     String filePathStr =
-        this.rootDirectory + classPackage + "/" + missedClass.getClassName() + ".java";
+        this.rootDirectory + classDirectory + "/" + missedClass.getClassName() + ".java";
     Path filePath = Path.of(filePathStr);
     try {
       Files.delete(filePath);
@@ -1162,6 +1265,7 @@ public void createMissingClass(UnsolvedClass missedClass) {
     String filePathStr =
         this.rootDirectory + classDirectory + "/" + missedClass.getClassName() + ".java";
     Path filePath = Paths.get(filePathStr);
+
     createdClass.add(filePath);
     try {
       Path parentPath = filePath.getParent();
@@ -1366,9 +1470,16 @@ public void updateTypes(
               + incorrectType.substring(1).replace("ReturnType", "");
       UnsolvedClass relatedClass = syntheticMethodAndClass.get(involvedMethod);
       if (relatedClass != null) {
+        for (UnsolvedClass syntheticClass : missingClass) {
+          if (syntheticClass.getClassName().equals(relatedClass.getClassName())
+              && syntheticClass.getPackageName().equals(relatedClass.getPackageName())) {
+            syntheticClass.updateMethodByReturnType(
+                incorrectType, typeToCorrect.get(incorrectType));
+            this.deleteOldSyntheticClass(syntheticClass);
+            this.createMissingClass(syntheticClass);
+          }
+        }
         relatedClass.updateMethodByReturnType(incorrectType, typeToCorrect.get(incorrectType));
-        this.deleteOldSyntheticClass(relatedClass);
-        this.createMissingClass(relatedClass);
       }
       // if the above condition is not met, then this incorrectType is a synthetic type for the
       // fields of the parent class rather than the return type of some methods

src/test/java/org/checkerframework/specimin/UnsolvedParameter.java

@@ -0,0 +1,15 @@
+package org.checkerframework.specimin;
+
+import java.io.IOException;
+import org.junit.Test;
+
+/** This test checks if Specimin can work for tricky, unsolved parameters. */
+public class UnsolvedParameter {
+  @Test
+  public void runTest() throws IOException {
+    SpeciminTestExecutor.runTestWithoutJarPaths(
+        "unsolvedparameter",
+        new String[] {"com/example/Simple.java"},
+        new String[] {"com.example.Simple#printName(FullName<MiddleName<String>, LastName>)"});
+  }
+}

src/test/resources/anonymousclass/expected/com/nameless/SomeClass.java

@@ -2,11 +2,11 @@
 
 public class SomeClass {
 
-    public SomeClass() {
+    public int getLocalVar() {
         throw new Error();
     }
 
-    public int getLocalVar() {
+    public SomeClass() {
         throw new Error();
     }
 }

src/test/resources/unsolvedparameter/expected/com/example/Simple.java

@@ -0,0 +1,11 @@
+package com.example;
+
+import com.name.FullName;
+import com.name.MiddleName;
+import com.name.LastName;
+
+public class Simple {
+
+    public void printName(FullName<MiddleName<String>, LastName> fullName) {
+    }
+}

src/test/resources/unsolvedparameter/expected/com/name/FullName.java

@@ -0,0 +1,4 @@
+package com.name;
+
+public class FullName<T, TT> {
+}

src/test/resources/unsolvedparameter/expected/com/name/LastName.java

@@ -0,0 +1,4 @@
+package com.name;
+
+public class LastName {
+}

src/test/resources/unsolvedparameter/expected/com/name/MiddleName.java

@@ -0,0 +1,4 @@
+package com.name;
+
+public class MiddleName<T> {
+}