Refactor

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

@@ -22,6 +22,7 @@
 import com.github.javaparser.ast.expr.FieldAccessExpr;
 import com.github.javaparser.ast.expr.LambdaExpr;
 import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.MethodReferenceExpr;
 import com.github.javaparser.ast.expr.ObjectCreationExpr;
 import com.github.javaparser.ast.expr.VariableDeclarationExpr;
 import com.github.javaparser.ast.nodeTypes.NodeWithDeclaration;
@@ -41,6 +42,7 @@
 import com.github.javaparser.resolution.declarations.AssociableToAST;
 import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
 import com.github.javaparser.resolution.declarations.ResolvedMethodLikeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
 import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
 import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
 import com.github.javaparser.resolution.types.ResolvedLambdaConstraintType;
@@ -51,17 +53,20 @@
 import com.google.common.base.Splitter;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 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 java.util.stream.Stream;
 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;
+import org.checkerframework.specimin.unsolved.SolvedMemberType;
 
 /**
  * A class containing useful static functions using JavaParser.
@@ -1131,6 +1136,60 @@ private static <T extends CallableDeclaration<?>> void addAllMatchingCallablesTo
     }
   }
 
+  /**
+   * Finds all unsolvable ancestors, given a type declaration to start.
+   *
+   * @param start The type declaration
+   * @param fqnToCompilationUnits A map of FQNs to compilation units
+   * @return A list of type declarations representing all unsolvable ancestors
+   */
+  public static List<ClassOrInterfaceType> getAllUnsolvableAncestors(
+      TypeDeclaration<?> start, Map<String, CompilationUnit> fqnToCompilationUnits) {
+    List<ClassOrInterfaceType> result = new ArrayList<>();
+
+    getAllUnsolvableAncestorsImpl(start, fqnToCompilationUnits, result);
+
+    return result;
+  }
+
+  /**
+   * Helper method for {@link #getAllUnsolvableAncestors(TypeDeclaration, Map)}. Recursively calls
+   * itself on all unsolvable ancestors.
+   *
+   * @param start The declaration to start at
+   * @param fqnToCompilationUnits The map of FQNs to compilation units
+   * @param result The
+   */
+  private static void getAllUnsolvableAncestorsImpl(
+      TypeDeclaration<?> start,
+      Map<String, CompilationUnit> fqnToCompilationUnits,
+      List<ClassOrInterfaceType> result) {
+    List<ClassOrInterfaceType> extendedOrImplemented = new ArrayList<>();
+
+    if (start instanceof NodeWithExtends<?> withExtends) {
+      extendedOrImplemented.addAll(withExtends.getExtendedTypes());
+    }
+    if (start instanceof NodeWithImplements<?> withImplements) {
+      extendedOrImplemented.addAll(withImplements.getImplementedTypes());
+    }
+
+    for (ClassOrInterfaceType type : extendedOrImplemented) {
+      try {
+        ResolvedType resolvedType = type.resolve();
+        TypeDeclaration<?> typeDecl =
+            getTypeFromQualifiedName(resolvedType.describe(), fqnToCompilationUnits);
+
+        if (typeDecl == null) {
+          continue;
+        }
+
+        getAllUnsolvableAncestorsImpl(typeDecl, fqnToCompilationUnits, result);
+      } catch (UnsolvedSymbolException ex) {
+        result.add(type);
+      }
+    }
+  }
+
   /**
    * Finds all solvable ancestors, given a type declaration to start.
    *
@@ -1819,4 +1878,105 @@ public static Node findClosestMethodOrLambdaAncestor(ReturnStmt returnStmt) {
 
     return null;
   }
+
+  /**
+   * Finds the least upper bound given a set of resolved types and solved member types.
+   *
+   * @param resolvedTypes The resolved types
+   * @param solvedMemberTypes The solved member types
+   * @return The least upper bound, or null if it is a primitive. Note that this is a
+   *     ResolvedReferenceTypeDeclaration because this does not consider type variables.
+   */
+  public static @Nullable ResolvedReferenceTypeDeclaration getLeastUpperBound(
+      List<ResolvedType> resolvedTypes, List<SolvedMemberType> solvedMemberTypes) {
+    if (resolvedTypes.isEmpty() && solvedMemberTypes.isEmpty()) {
+      throw new RuntimeException("No types available to compute least upper bound");
+    }
+
+    List<ResolvedReferenceTypeDeclaration> combined = new ArrayList<>();
+
+    for (ResolvedType resolvedType : resolvedTypes) {
+      if (!resolvedType.isReferenceType()) {
+        // May be a type variable
+        continue;
+      }
+
+      combined.add(resolvedType.asReferenceType().getTypeDeclaration().get());
+    }
+
+    for (SolvedMemberType solvedMemberType : solvedMemberTypes) {
+      String fqn = solvedMemberType.getFullyQualifiedNames().iterator().next();
+      if (JavaLangUtils.isPrimitive(fqn)) {
+        break;
+      }
+
+      try {
+        combined.add(getTypeSolver().solveType(fqn));
+      } catch (UnsolvedSymbolException e) {
+        // Type param, likely
+      }
+    }
+
+    if (combined.isEmpty()) {
+      return null;
+    }
+
+    Set<ResolvedReferenceTypeDeclaration> intersectedAncestors =
+        Stream.concat(
+                combined.get(0).getAllAncestors().stream()
+                    .map(anc -> anc.getTypeDeclaration().get()),
+                Stream.of(combined.get(0)))
+            .collect(Collectors.toCollection(HashSet::new));
+
+    for (ResolvedReferenceTypeDeclaration typeDecl : combined) {
+      intersectedAncestors.retainAll(
+          Stream.concat(
+                  typeDecl.getAllAncestors().stream().map(anc -> anc.getTypeDeclaration().get()),
+                  Stream.of(typeDecl))
+              .toList());
+    }
+
+    return intersectedAncestors.stream()
+        .min(
+            (a, b) -> {
+              if (a.isAssignableBy(b)) return 1;
+              if (b.isAssignableBy(a)) return -1;
+
+              // Prefer a class lub to an interface lub
+              if (a.isClass() && !b.isClass()) return -1;
+              if (!a.isClass() && b.isClass()) return 1;
+
+              return 0;
+            })
+        .get();
+  }
+
+  /**
+   * Given a method reference expression, find all possible methods it could be referring to. If the
+   * method reference scope type is unsolvable or no methods of matching name could be found (maybe
+   * in an unsolved ancestor), then this method returns an empty list.
+   *
+   * @param methodReference The method reference to find declarations of
+   * @return The list of matching resolved method declarations or an empty list if none could be
+   *     found
+   */
+  public static List<? extends ResolvedMethodLikeDeclaration> getMethodDeclarationsFromMethodRef(
+      MethodReferenceExpr methodReference) {
+    if (!isExprTypeResolvable(methodReference.getScope())) {
+      return Collections.emptyList();
+    }
+
+    ResolvedType methodDeclaringType = methodReference.getScope().calculateResolvedType();
+
+    String methodName = methodReference.getIdentifier();
+
+    if (methodName.equals("new")) {
+      return methodDeclaringType.asReferenceType().getTypeDeclaration().get().getConstructors();
+    }
+
+    // Method references must be on reference types
+    return methodDeclaringType.asReferenceType().getAllMethods().stream()
+        .filter(method -> method.getName().equals(methodName))
+        .toList();
+  }
 }

src/main/java/org/checkerframework/specimin/unsolved/FullyQualifiedNameGenerator.java

@@ -15,6 +15,7 @@
 import com.github.javaparser.ast.expr.AssignExpr;
 import com.github.javaparser.ast.expr.BinaryExpr;
 import com.github.javaparser.ast.expr.BinaryExpr.Operator;
+import com.github.javaparser.ast.expr.ConditionalExpr;
 import com.github.javaparser.ast.expr.Expression;
 import com.github.javaparser.ast.expr.LambdaExpr;
 import com.github.javaparser.ast.expr.MethodReferenceExpr;
@@ -708,7 +709,19 @@ private FullyQualifiedNameSet getFQNsForLambdaType(LambdaExpr lambda) {
   private @Nullable FullyQualifiedNameSet getFQNsForTypeOfSolvableExpression(
       Resolvable<?> resolvable) {
     Node node = null;
-    Object resolved = resolvable.resolve();
+    Object resolved;
+
+    try {
+      resolved = resolvable.resolve();
+    } catch (UnsupportedOperationException ex) {
+      if (resolvable instanceof Expression expr) {
+        resolved =
+            JavaParserUtil.tryFindCorrespondingDeclarationForConstraintQualifiedExpression(
+                (Expression) resolvable);
+      } else {
+        throw ex;
+      }
+    }
 
     if (resolved instanceof AssociableToAST associableToAST) {
       node = JavaParserUtil.tryFindAttachedNode(associableToAST, fqnToCompilationUnits);
@@ -845,11 +858,22 @@ else if (parentNode instanceof NodeWithCondition<?> withCondition) {
       if (withCondition.getCondition().equals(expr)) {
         return new FullyQualifiedNameSet("boolean");
       }
+
+      if (withCondition instanceof ConditionalExpr conditionalExpr && canRecurse) {
+        Expression other;
+
+        if (conditionalExpr.getThenExpr().equals(expr)) {
+          other = conditionalExpr.getElseExpr();
+        } else {
+          other = conditionalExpr.getThenExpr();
+        }
+
+        return getFQNsForExpressionTypeImpl(other, false);
+      }
     }
     // If it's in a binary expression (i.e., + - / * == != etc.), then set it to the type of the
     // other side, if known
-    else if (parentNode instanceof BinaryExpr && canRecurse) {
-      BinaryExpr binary = (BinaryExpr) parentNode;
+    else if (parentNode instanceof BinaryExpr binary && canRecurse) {
       Operator operator = binary.getOperator();
 
       Expression other;

src/main/java/org/checkerframework/specimin/unsolved/MemberType.java

@@ -40,11 +40,10 @@ public List<MemberType> getTypeArguments() {
   }
 
   /**
-   * Sets the type arguments for this type.
+   * Utility method to return a copy of this member type with new type arguments.
    *
-   * @param typeArguments The list of member types representing the type arguments of this type
+   * @param newTypeArgs The new type arguments to use for the copy
+   * @return A copy of this member type with the specified type arguments
    */
-  public void setTypeArguments(List<MemberType> typeArguments) {
-    this.typeArguments = typeArguments;
-  }
+  public abstract MemberType copyWithNewTypeArgs(List<MemberType> newTypeArgs);
 }

src/main/java/org/checkerframework/specimin/unsolved/SolvedMemberType.java

@@ -19,6 +19,9 @@ public class SolvedMemberType extends MemberType {
   /** Represents java.lang.Error */
   public static final SolvedMemberType JAVA_LANG_ERROR = new SolvedMemberType("java.lang.Error");
 
+  /** Represents java.lang.Object */
+  public static final SolvedMemberType JAVA_LANG_OBJECT = new SolvedMemberType("java.lang.Object");
+
   private String fqn;
 
   /**
@@ -85,11 +88,17 @@ public boolean equals(@Nullable Object other) {
       return false;
     }
 
-    return Objects.equals(otherAsSolvedMemberType.fqn, this.fqn);
+    return Objects.equals(otherAsSolvedMemberType.fqn, this.fqn)
+        && Objects.equals(otherAsSolvedMemberType.getTypeArguments(), this.getTypeArguments());
   }
 
   @Override
   public int hashCode() {
-    return Objects.hashCode(fqn);
+    return Objects.hash(fqn, getTypeArguments());
+  }
+
+  @Override
+  public MemberType copyWithNewTypeArgs(List<MemberType> newTypeArgs) {
+    return new SolvedMemberType(fqn, newTypeArgs);
   }
 }