Refactor

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

@@ -50,13 +50,16 @@
 import com.github.javaparser.utils.Pair;
 import com.google.common.base.Splitter;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
+import org.checkerframework.checker.nullness.qual.EnsuresNonNull;
+import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.checker.signature.qual.FullyQualifiedName;
 
@@ -81,13 +84,14 @@ private JavaParserUtil() {
    * through reflection in JavaParserSymbolSolver. This field is initialized once in SpeciminRunner.
    * Note that by the time you evaluate the value of this field, it should already be non-null.
    */
-  private static @Nullable TypeSolver typeSolver = null;
+  private static @MonotonicNonNull TypeSolver typeSolver = null;
 
   /**
    * Set the TypeSolver instance to be used by the JavaParserFacade.
    *
    * @param typeSolver the TypeSolver instance to set
    */
+  @EnsuresNonNull("JavaParserUtil.typeSolver")
   public static void setTypeSolver(TypeSolver typeSolver) {
     JavaParserUtil.typeSolver = typeSolver;
   }
@@ -1521,8 +1525,7 @@ public static String getInitializerRHS(String variableType) {
 
       // Don't use a map here: in case a ResolvedType is the same for different parameters, we could
       // have different pieces of information (i.e., two parameters are both resolved type T, but
-      // the args
-      // could be different in the method call)
+      // the args could be different in the method call)
       List<Pair<ResolvedType, ResolvedType>> resolvedTypeToPotentialASTTypes = new ArrayList<>();
 
       if (methodCallParent.getParentNode().orElse(null) instanceof ReturnStmt returnStmt
@@ -1671,4 +1674,142 @@ public static String getInitializerRHS(String variableType) {
 
     return null;
   }
+
+  /**
+   * Given a list, return all subsets.
+   *
+   * @param original The original list
+   * @return A list of all subsets
+   */
+  public static <T> List<List<T>> generateSubsets(List<T> original) {
+    List<List<T>> subsets = new ArrayList<>();
+    // There are 2^n - 1 subsets; each bit will determine if an element is included
+    int totalSubsets = 1 << original.size();
+
+    for (int i = 0; i < totalSubsets; i++) {
+      List<T> subset = new ArrayList<>();
+      for (int j = 0; j < original.size(); j++) {
+        if ((i & (1 << j)) != 0) {
+          subset.add(original.get(j));
+        }
+      }
+      subsets.add(subset);
+    }
+
+    return subsets;
+  }
+
+  /**
+   * Given a list of collections, return all combinations of elements where one element is picked
+   * from each collection. For example, if you input a list [[1, 2], [3]], then output [[1, 3], [2,
+   * 3]].
+   *
+   * @param collections The list of collections to combine
+   * @return A list of all combinations of elements
+   */
+  public static <T> List<List<T>> generateAllCombinations(
+      List<? extends Collection<T>> collections) {
+    List<List<T>> combos = new ArrayList<>();
+    combos.add(new ArrayList<>());
+
+    for (Collection<T> set : collections) {
+      int stop = combos.size();
+      for (int i = 0; i < stop; i++) {
+        List<T> combination = combos.get(i);
+        for (T element : set) {
+          List<T> newCombination = new ArrayList<>(combination);
+          newCombination.add(element);
+          combos.add(newCombination);
+        }
+      }
+    }
+
+    // The first element will always be an empty list, so we'll remove it
+    combos.remove(0);
+
+    return combos;
+  }
+
+  /**
+   * Finds the closest method or lambda ancestor of a return statement. Will throw if neither is
+   * found, since a return statement is always located in one of these contexts.
+   *
+   * @param returnStmt The return statement
+   * @return The closest method or lambda ancestor (either of type MethodDeclaration or LambdaExpr)
+   */
+  public static Node findClosestMethodOrLambdaAncestor(ReturnStmt returnStmt) {
+    @SuppressWarnings("unchecked")
+    Node ancestor =
+        returnStmt
+            .<Node>findAncestor(
+                n -> {
+                  return n instanceof MethodDeclaration || n instanceof LambdaExpr;
+                },
+                Node.class)
+            .get();
+    return ancestor;
+  }
+
+  /**
+   * This method handles a very specific case: if an unsolved method call has a scope whose type is
+   * a supertype of the type this method is being called in, then it will try to find a method with
+   * the same signature in the current type or a solvable supertype.
+   *
+   * @param methodCall The method call, unsolved
+   * @param fqnToCompilationUnit The map of FQNs to compilation units
+   * @return A method declaration if found, or null if not
+   */
+  public static @Nullable MethodDeclaration tryFindMethodDeclarationWithSameSignatureFromThisType(
+      MethodCallExpr methodCall, Map<String, CompilationUnit> fqnToCompilationUnit) {
+    if (!methodCall.hasScope()) {
+      return null;
+    }
+
+    Expression scope = methodCall.getScope().get();
+
+    Type scopeType = tryGetTypeFromExpression(scope, fqnToCompilationUnit);
+
+    if (scopeType == null) {
+      return null;
+    }
+
+    TypeDeclaration<?> enclosingClass = getEnclosingClassLike(methodCall);
+
+    List<TypeDeclaration<?>> solvableAncestors =
+        getAllSolvableAncestors(enclosingClass, fqnToCompilationUnit);
+
+    solvableAncestors.add(enclosingClass);
+
+    boolean isScopeTypeAnAncestor = false;
+    for (TypeDeclaration<?> thisOrAncestor : solvableAncestors) {
+      if (thisOrAncestor instanceof NodeWithExtends<?> withExtends
+          && withExtends.getExtendedTypes().contains(scopeType)) {
+        isScopeTypeAnAncestor = true;
+        break;
+      } else if (thisOrAncestor instanceof NodeWithImplements<?> withImplements
+          && withImplements.getImplementedTypes().contains(scopeType)) {
+        isScopeTypeAnAncestor = true;
+        break;
+      }
+    }
+
+    if (!isScopeTypeAnAncestor) {
+      return null;
+    }
+
+    MethodCallExpr clone = methodCall.clone();
+    clone.removeScope();
+    clone.setParentNode(methodCall.getParentNode().get());
+
+    List<MethodDeclaration> methods =
+        tryResolveMethodCallWithUnresolvableArguments(clone, fqnToCompilationUnit);
+
+    clone.remove();
+
+    if (methods.size() == 1) {
+      return methods.get(0);
+    }
+
+    return null;
+  }
 }

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

@@ -10,6 +10,7 @@
 import com.github.javaparser.ast.body.MethodDeclaration;
 import com.github.javaparser.ast.body.TypeDeclaration;
 import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.expr.AssignExpr;
 import com.github.javaparser.ast.expr.Expression;
 import com.github.javaparser.ast.expr.FieldAccessExpr;
 import com.github.javaparser.ast.expr.MethodCallExpr;
@@ -24,7 +25,10 @@
 import com.github.javaparser.ast.type.UnknownType;
 import com.github.javaparser.resolution.Resolvable;
 import com.github.javaparser.resolution.UnsolvedSymbolException;
+import com.github.javaparser.resolution.declarations.ResolvedFieldDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
 import com.github.javaparser.resolution.types.ResolvedType;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Deque;
@@ -69,7 +73,7 @@ public class Slicer {
    * are guaranteed to be generated. Contains only select Nodes, determined by {@link
    * UnsolvedSymbolGenerator#needToPostProcess(Node)}.
    */
-  private final Set<Node> postProcessingWorklist = new LinkedHashSet<>();
+  private final Deque<Node> postProcessingWorklist = new ArrayDeque<>();
 
   /** The result of the slice, not including generated symbols. */
   private final Set<CompilationUnit> resultCompilationUnits = new HashSet<>();
@@ -129,6 +133,8 @@ public static SliceResult slice(
       }
     }
 
+    unsolvedSymbolGenerator.generateAllAlternatesBasedOnSuperTypeRelationships();
+
     slicer.prune();
 
     return new SliceResult(
@@ -146,6 +152,8 @@ private void buildSlice() {
       handleElement(element);
     }
 
+    generatedSymbolSlice.addAll(unsolvedSymbolGenerator.clearMethodsWithNull());
+
     if (!generatedSymbolSlice.isEmpty()) {
       // Step 2: Add more information to generated symbols based on context
       Iterator<Node> ppwIterator = postProcessingWorklist.iterator();
@@ -451,6 +459,66 @@ private void removeNonSliceNodes(Node node) {
       for (Node child : copy) {
         removeNonSliceNodes(child);
       }
+
+      // If we encounter an empty final field, try to see if we've included an assignment expression
+      // that sets it in the slice. If not, then we need to add a default initializer.
+      if (node instanceof VariableDeclarator fieldDeclarator
+          && fieldDeclarator.getInitializer().isEmpty()
+          && fieldDeclarator.getParentNode().get() instanceof FieldDeclaration fieldDecl
+          && fieldDecl.isFinal()) {
+        ResolvedFieldDeclaration resolved = (ResolvedFieldDeclaration) fieldDeclarator.resolve();
+
+        boolean isSet =
+            slice.stream()
+                .filter(n -> n instanceof AssignExpr)
+                .map(n -> (AssignExpr) n)
+                .filter(
+                    assignExpr -> {
+                      if (assignExpr.getTarget().isFieldAccessExpr()) {
+                        try {
+                          ResolvedValueDeclaration target =
+                              assignExpr.getTarget().asFieldAccessExpr().resolve();
+
+                          if (target.isField()) {
+                            return target
+                                    .asField()
+                                    .declaringType()
+                                    .getQualifiedName()
+                                    .equals(resolved.declaringType().getQualifiedName())
+                                && target.getName().equals(resolved.getName());
+                          }
+                        } catch (UnsolvedSymbolException e) {
+                          return false;
+                        }
+                      } else if (assignExpr.getTarget().isNameExpr()) {
+                        try {
+                          ResolvedValueDeclaration target =
+                              assignExpr.getTarget().asNameExpr().resolve();
+
+                          if (target.isField()) {
+                            return target
+                                    .asField()
+                                    .declaringType()
+                                    .getQualifiedName()
+                                    .equals(resolved.declaringType().getQualifiedName())
+                                && target.getName().equals(resolved.getName());
+                          }
+                          return target.equals(resolved);
+                        } catch (UnsolvedSymbolException e) {
+                          return false;
+                        }
+                      }
+
+                      return false;
+                    })
+                .findFirst()
+                .isPresent();
+
+        if (!isSet) {
+          fieldDeclarator.setInitializer(
+              JavaParserUtil.getInitializerRHS(fieldDeclarator.getType().toString()));
+        }
+      }
     }
     // If a BlockStmt is being removed, it's a method/constructor to be trimmed
     else if (node instanceof BlockStmt blockStmt