Crash fix for UnionType parameter in Issue #38

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

@@ -16,6 +16,7 @@
 import com.github.javaparser.ast.stmt.ExplicitConstructorInvocationStmt;
 import com.github.javaparser.ast.type.ReferenceType;
 import com.github.javaparser.ast.type.Type;
+import com.github.javaparser.ast.type.UnionType;
 import com.github.javaparser.ast.visitor.ModifierVisitor;
 import com.github.javaparser.ast.visitor.Visitable;
 import com.github.javaparser.resolution.UnsolvedSymbolException;
@@ -223,24 +224,21 @@ public Visitable visit(MethodDeclaration method, Void p) {
   public Visitable visit(Parameter para, Void p) {
     if (insideTargetMethod) {
       Type type = para.getType();
-      String paraTypeFullName = "";
-      ResolvedType paramType;
       if (type.isUnionType()) {
-        for (ReferenceType param : para.getType().asUnionType().getElements()) {
-          paramType = param.resolve();
-          paraTypeFullName =
-              paramType.asReferenceType().getTypeDeclaration().get().getQualifiedName();
-          usedClass.add(paraTypeFullName);
-        }
+        resolveUnionType(type.asUnionType());
       } else {
+        // Parameter resolution (para.resolve()) does not work in catch clause.
+        // However, resolution works on the type of the parameter.
+        // Bug report: https://github.com/javaparser/javaparser/issues/4240
+        ResolvedType paramType;
         if (para.getParentNode().isPresent() && para.getParentNode().get() instanceof CatchClause) {
           paramType = para.getType().resolve();
         } else {
           paramType = para.resolve().getType();
         }
 
         if (paramType.isReferenceType()) {
-          paraTypeFullName =
+          String paraTypeFullName =
               paramType.asReferenceType().getTypeDeclaration().get().getQualifiedName();
           usedClass.add(paraTypeFullName);
           for (ResolvedType typeParameterValue :
@@ -330,4 +328,16 @@ public Visitable visit(NameExpr expr, Void p) {
     }
     return super.visit(expr, p);
   }
+
+  /**
+   * @param type unionType parameter
+   */
+  private void resolveUnionType(UnionType type) {
+    for (ReferenceType param : type.getElements()) {
+      ResolvedType paramType = param.resolve();
+      String paraTypeFullName =
+          paramType.asReferenceType().getTypeDeclaration().get().getQualifiedName();
+      usedClass.add(paraTypeFullName);
+    }
+  }
 }

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

@@ -188,18 +188,11 @@ 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(getTypeVariablesAsString());
     if (isExceptionType) {
-      sb.append("public class ")
-          .append(className)
-          .append(getTypeVariablesAsString())
-          .append(" extends Exception")
-          .append(" {\n");
-    } else {
-      sb.append("public class ")
-          .append(className)
-          .append(getTypeVariablesAsString())
-          .append(" {\n");
+      sb.append(" extends Exception");
     }
+    sb.append(" {\n");
     for (String variableDeclarations : classFields) {
       sb.append("    " + "public " + variableDeclarations + ";\n");
     }

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

@@ -528,11 +528,7 @@ public Visitable visit(MethodDeclaration node, Void arg) {
       try {
         nodeType.resolve();
       } catch (UnsolvedSymbolException | UnsupportedOperationException e) {
-        // if the class could not be found among import statements, we assume that the class must be
-        // in the same package as the current class.
-        String packageName = classAndPackageMap.getOrDefault(nodeTypeSimpleForm, currentPackage);
-        UnsolvedClass syntheticType = new UnsolvedClass(nodeTypeSimpleForm, packageName);
-        this.updateMissingClass(syntheticType);
+        updateUnsolvedClassWithClassName(nodeTypeSimpleForm, false);
       }
     }
 
@@ -699,12 +695,7 @@ public Visitable visit(ObjectCreationExpr newExpr, Void p) {
     try {
       List<String> argumentsCreation = getArgumentsFromObjectCreation(newExpr);
       UnsolvedMethod creationMethod = new UnsolvedMethod("", type, argumentsCreation);
-      // we assume that an unsolved class not found among import statements should be in the same
-      // package as the current class
-      String packageName = classAndPackageMap.getOrDefault(type, currentPackage);
-      UnsolvedClass newClass = new UnsolvedClass(type, packageName);
-      newClass.addMethod(creationMethod);
-      this.updateMissingClass(newClass);
+      updateUnsolvedClassWithClassName(type, false, creationMethod);
     } catch (Exception q) {
       // can not solve the parameters for this object creation in this current run
     }
@@ -728,15 +719,12 @@ private void handleParameterResolveFailure(@NonNull Parameter parameter) {
     } else {
       // since it is unsolved, it could not be a primitive type
       @ClassGetSimpleName String className = parameter.getType().asClassOrInterfaceType().getName().asString();
-      String packageName = classAndPackageMap.getOrDefault(className, currentPackage);
-      UnsolvedClass newClass;
       if (parameter.getParentNode().isPresent()
           && parameter.getParentNode().get() instanceof CatchClause) {
-        newClass = new UnsolvedClass(className, packageName, true);
+        updateUnsolvedClassWithClassName(className, true);
       } else {
-        newClass = new UnsolvedClass(className, packageName);
+        updateUnsolvedClassWithClassName(className, false);
       }
-      updateMissingClass(newClass);
     }
   }
 
@@ -841,11 +829,8 @@ public void updateUnsolvedClassWithMethod(
     } else {
       returnType = desiredReturnType;
     }
-    // a class not found among import statements should be in the same package as the current class
-    UnsolvedClass missingClass =
-        new UnsolvedClass(className, classAndPackageMap.getOrDefault(className, currentPackage));
     UnsolvedMethod thisMethod = new UnsolvedMethod(methodName, returnType, listOfParameters);
-    UnsolvedClass missingClass = updateUnsolvedClassWithClassName(className, thisMethod);
+    UnsolvedClass missingClass = updateUnsolvedClassWithClassName(className, false, thisMethod);
     syntheticMethodAndClass.put(methodName, missingClass);
 
     // if the return type is not specified, a synthetic return type will be created. This part of
@@ -928,15 +913,18 @@ public void updateClassesFromJarSourcesForMethodCall(MethodCallExpr expr) {
    * @param nameOfClass the name of an unsolved class
    * @param unsolvedMethods unsolved methods to add to the class before updating this visitor's set
    *     missing classes (optional, may be omitted)
+   * @param isExceptionType if the class is of exceptionType
    * @return the newly-created UnsolvedClass method, for further processing. This output may be
    *     ignored.
    */
   public UnsolvedClass updateUnsolvedClassWithClassName(
-      @ClassGetSimpleName String nameOfClass, UnsolvedMethod... unsolvedMethods) {
+      @ClassGetSimpleName String nameOfClass,
+      boolean isExceptionType,
+      UnsolvedMethod... unsolvedMethods) {
     // if the name of the class is not present among import statements, we assume that this unsolved
     // class is in the same directory as the current class
     String packageName = classAndPackageMap.getOrDefault(nameOfClass, currentPackage);
-    UnsolvedClass result = new UnsolvedClass(nameOfClass, packageName);
+    UnsolvedClass result = new UnsolvedClass(nameOfClass, packageName, isExceptionType);
     for (UnsolvedMethod unsolvedMethod : unsolvedMethods) {
       result.addMethod(unsolvedMethod);
     }