From 8057f2d77bfc13960ce7dc1cebf579f8b27abb20 Mon Sep 17 00:00:00 2001
From: Martin Kellogg <martin.kellogg@njit.edu>
Date: Tue, 14 May 2024 15:01:19 -0400
Subject: [PATCH 01/10] failing test

---
 .../specimin/MethodRef2Test.java               | 18 ++++++++++++++++++
 .../expected/com/example/Simple.java           | 13 +++++++++++++
 .../input/com/example/MethodSignature.java     |  8 ++++++++
 .../methodref2/input/com/example/Simple.java   | 16 ++++++++++++++++
 4 files changed, 55 insertions(+)
 create mode 100644 src/test/java/org/checkerframework/specimin/MethodRef2Test.java
 create mode 100644 src/test/resources/methodref2/expected/com/example/Simple.java
 create mode 100644 src/test/resources/methodref2/input/com/example/MethodSignature.java
 create mode 100644 src/test/resources/methodref2/input/com/example/Simple.java

diff --git a/src/test/java/org/checkerframework/specimin/MethodRef2Test.java b/src/test/java/org/checkerframework/specimin/MethodRef2Test.java
new file mode 100644
index 00000000..66fb9486
--- /dev/null
+++ b/src/test/java/org/checkerframework/specimin/MethodRef2Test.java
@@ -0,0 +1,18 @@
+package org.checkerframework.specimin;
+
+import java.io.IOException;
+import org.junit.Test;
+
+/**
+ * A test for a crash related to method signatures that occurred in Randoop:
+ * https://github.com/njit-jerse/specimin/issues/154
+ */
+public class MethodRef2Test {
+  @Test
+  public void runTest() throws IOException {
+    SpeciminTestExecutor.runTestWithoutJarPaths(
+        "methodref2",
+        new String[] {"com/example/Simple.java"},
+        new String[] {"com.example.Simple#bar()"});
+  }
+}
diff --git a/src/test/resources/methodref2/expected/com/example/Simple.java b/src/test/resources/methodref2/expected/com/example/Simple.java
new file mode 100644
index 00000000..3a35e628
--- /dev/null
+++ b/src/test/resources/methodref2/expected/com/example/Simple.java
@@ -0,0 +1,13 @@
+package com.example;
+
+class Simple {
+
+    void bar() {
+        Object obj = new Object();
+        obj = baz(obj);
+    }
+
+    Object baz(Object obj) {
+        throw new Error();
+    }
+}
diff --git a/src/test/resources/methodref2/input/com/example/MethodSignature.java b/src/test/resources/methodref2/input/com/example/MethodSignature.java
new file mode 100644
index 00000000..edc60f18
--- /dev/null
+++ b/src/test/resources/methodref2/input/com/example/MethodSignature.java
@@ -0,0 +1,8 @@
+package com.example;
+
+public class MethodSignature {
+    @Override
+    public String toString() {
+        return "a string";
+    }
+}
\ No newline at end of file
diff --git a/src/test/resources/methodref2/input/com/example/Simple.java b/src/test/resources/methodref2/input/com/example/Simple.java
new file mode 100644
index 00000000..da478e0d
--- /dev/null
+++ b/src/test/resources/methodref2/input/com/example/Simple.java
@@ -0,0 +1,16 @@
+package com.example;
+
+import java.util.Map;
+
+import org.plumelib.util.CollectionsPlume;
+
+class Simple {
+
+    Map<MethodSignature, MethodSignature> replacementMap;
+
+    // Target method.
+    void bar() {
+        List<String> signatureList =
+                CollectionsPlume.mapList(MethodSignature::toString, replacementMap.keySet());
+    }
+}

From 1970e98e5a33b8f32af0a1f5fa9e80c5a188f562 Mon Sep 17 00:00:00 2001
From: Martin Kellogg <martin.kellogg@njit.edu>
Date: Tue, 14 May 2024 15:13:17 -0400
Subject: [PATCH 02/10] some wip code that's probably necessary to get this to
 work but is not the proximate cause of the crash

---
 build.gradle                                    |  2 +-
 .../specimin/UnsolvedSymbolVisitor.java         | 17 +++++++++++++++++
 .../methodref2/input/com/example/Simple.java    |  1 +
 3 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index e12d485a..c34cd1bf 100644
--- a/build.gradle
+++ b/build.gradle
@@ -63,7 +63,7 @@ tasks.compileJava {
 
 checkerFramework {
     // uncomment for testing
-    // skipCheckerFramework = true
+     skipCheckerFramework = true
     checkers = [
             'org.checkerframework.checker.nullness.NullnessChecker',
             'org.checkerframework.checker.resourceleak.ResourceLeakChecker',
diff --git a/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java b/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
index ca34c4d7..64ba271b 100644
--- a/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
+++ b/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
@@ -20,6 +20,7 @@
 import com.github.javaparser.ast.expr.InstanceOfExpr;
 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.NameExpr;
 import com.github.javaparser.ast.expr.ObjectCreationExpr;
 import com.github.javaparser.ast.expr.PatternExpr;
@@ -1069,6 +1070,22 @@ public Visitable visit(FieldAccessExpr node, Void p) {
     return super.visit(node, p);
   }
 
+  @Override
+  public Visitable visit(MethodReferenceExpr node, Void p) {
+    if (insideTargetMember) {
+      // scope can be ignored - our other rules should handle that
+      String identifier = node.getIdentifier();
+      // can be either the name of a method or "new"
+      if ("new".equals(identifier)) {
+        // TODO: figure out how to handle this case
+        System.err.println("Specimin warning: new in method references is not supported: " + node);
+        return super.visit(node, p);
+      }
+      potentialUsedMembers.add(identifier);
+    }
+    return super.visit(node, p);
+  }
+
   @Override
   public Visitable visit(MethodCallExpr method, Void p) {
     /*
diff --git a/src/test/resources/methodref2/input/com/example/Simple.java b/src/test/resources/methodref2/input/com/example/Simple.java
index da478e0d..3a0d39cc 100644
--- a/src/test/resources/methodref2/input/com/example/Simple.java
+++ b/src/test/resources/methodref2/input/com/example/Simple.java
@@ -1,6 +1,7 @@
 package com.example;
 
 import java.util.Map;
+import java.util.List;
 
 import org.plumelib.util.CollectionsPlume;
 

From 8521483dec408f2ba26f25954480cbadda6c816d Mon Sep 17 00:00:00 2001
From: Martin Kellogg <martin.kellogg@njit.edu>
Date: Fri, 17 May 2024 09:49:49 -0400
Subject: [PATCH 03/10] well, it passes the test. But this is definitely
 avoiding the hard problem: method references don't tell you what their arity
 is the way that lambdas do...

---
 .../specimin/JavaTypeCorrect.java             |  1 +
 .../specimin/SpeciminRunner.java              |  5 ++
 .../specimin/UnsolvedSymbolVisitor.java       | 84 ++++++++++++++++++-
 .../expected/com/example/Simple.java          | 14 ++--
 4 files changed, 95 insertions(+), 9 deletions(-)

diff --git a/src/main/java/org/checkerframework/specimin/JavaTypeCorrect.java b/src/main/java/org/checkerframework/specimin/JavaTypeCorrect.java
index 01541c05..30295a89 100644
--- a/src/main/java/org/checkerframework/specimin/JavaTypeCorrect.java
+++ b/src/main/java/org/checkerframework/specimin/JavaTypeCorrect.java
@@ -257,6 +257,7 @@ public void runJavacAndUpdateTypes(String filePath) {
           }
         }
       }
+      System.out.println("error messages from javac: " + lines);
     } catch (IOException e) {
       // TODO: Handle this properly
       System.out.println(e);
diff --git a/src/main/java/org/checkerframework/specimin/SpeciminRunner.java b/src/main/java/org/checkerframework/specimin/SpeciminRunner.java
index 79a523ce..20156ad0 100644
--- a/src/main/java/org/checkerframework/specimin/SpeciminRunner.java
+++ b/src/main/java/org/checkerframework/specimin/SpeciminRunner.java
@@ -271,6 +271,8 @@ private static void performMinimizationImpl(
               addMissingClass.getAddedTargetFiles(),
               addMissingClass.getSyntheticClassesAsAStringSet());
 
+      System.out.println("current state: " + workDoneAfterIteration);
+
       // Infinite loop protection.
       boolean gettingStuck = previousIterations.contains(workDoneAfterIteration);
       if (gettingStuck) {
@@ -289,6 +291,9 @@ private static void performMinimizationImpl(
       }
       previousIterations.add(workDoneAfterIteration);
 
+      System.out.println("getting stuck? " + gettingStuck);
+      System.out.println("getting exceptions? " + addMissingClass.gettingException());
+
       if (gettingStuck || !addMissingClass.gettingException()) {
         // Three possible cases here:
         // 1: addMissingClass has finished its iteration.
diff --git a/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java b/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
index 64ba271b..a4144e3b 100644
--- a/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
+++ b/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
@@ -1072,8 +1072,23 @@ public Visitable visit(FieldAccessExpr node, Void p) {
 
   @Override
   public Visitable visit(MethodReferenceExpr node, Void p) {
+    System.out.println("visiting a method ref: " + node);
     if (insideTargetMember) {
-      // scope can be ignored - our other rules should handle that
+      // TODO: handle all of the possible forms listed in JLS 15.13, not just the simplest
+      Expression scope = node.getScope();
+      if (scope.isTypeExpr()) {
+        Type scopeAsType = scope.asTypeExpr().getType();
+        String scopeAsTypeFQN = scopeAsType.asString();
+        if (!isAClassPath(scopeAsTypeFQN) && scopeAsType.isClassOrInterfaceType()) {
+          scopeAsTypeFQN =
+              getQualifiedNameForClassOrInterfaceType(scopeAsType.asClassOrInterfaceType());
+        }
+        if (classfileIsInOriginalCodebase(scopeAsTypeFQN)) {
+          addedTargetFiles.add(qualifiedNameToFilePath(scopeAsTypeFQN));
+        } else {
+          // TODO: create a synthetic class?
+        }
+      }
       String identifier = node.getIdentifier();
       // can be either the name of a method or "new"
       if ("new".equals(identifier)) {
@@ -1081,6 +1096,8 @@ public Visitable visit(MethodReferenceExpr node, Void p) {
         System.err.println("Specimin warning: new in method references is not supported: " + node);
         return super.visit(node, p);
       }
+      System.out.println(
+          "adding this identifier to the list of potential used members: " + identifier);
       potentialUsedMembers.add(identifier);
     }
     return super.visit(node, p);
@@ -1093,16 +1110,38 @@ public Visitable visit(MethodCallExpr method, Void p) {
      * We ensure that the caller and its parameters are resolved before solving the method itself.
      * For instance, in a method call like a.b(c, d, e,...), we solve a, c, d, e,... before resolving b.
      */
+    System.out.println("visiting a method call: " + method);
     if (!insideTargetMember) {
+      System.out.println("1");
       return super.visit(method, p);
     }
     potentialUsedMembers.add(method.getName().asString());
     if (canBeSolved(method) && isFromAJarFile(method)) {
       updateClassesFromJarSourcesForMethodCall(method);
+      System.out.println("2");
       return super.visit(method, p);
     }
     // we will wait for the next run to solve this method call
     if (!canSolveArguments(method.getArguments())) {
+      if (hasUnsolvedReceiverLikeClassName(method)) {
+        // Make sure that we try to solve the receiver first if
+        // it looks like a class name and is unsolved, because otherwise
+        // it might prevent us from solving the rest of the arguments.
+        // The receiver is guaranteed to be present by the check above.
+        Expression receiver = method.getScope().orElseThrow();
+        System.out.println("triggering the special case: " + receiver);
+        String typeName = receiver.toString();
+        String pkgName;
+        if (isAClassPath(typeName)) {
+          pkgName = typeName.substring(0, typeName.lastIndexOf('.'));
+          typeName = typeName.substring(typeName.lastIndexOf('.') + 1);
+        } else {
+          pkgName = getPackageFromClassName(typeName);
+        }
+        UnsolvedClassOrInterface receiverClass = new UnsolvedClassOrInterface(typeName, pkgName);
+        updateMissingClass(receiverClass);
+        this.gotException();
+      }
       return super.visit(method, p);
     }
     if (isASuperCall(method) && !canBeSolved(method)) {
@@ -1112,6 +1151,7 @@ public Visitable visit(MethodCallExpr method, Void p) {
     if (isAnUnsolvedStaticMethodCalledByAQualifiedClassName(method)) {
       updateClassSetWithStaticMethodCall(method);
     } else if (unsolvedAndCalledByASimpleClassName(method)) {
+      System.out.println("4");
       updateClassSetWithStaticMethodCall(method);
     } else if (calledByAnIncompleteClass(method)) {
       /*
@@ -1165,6 +1205,34 @@ public Visitable visit(MethodCallExpr method, Void p) {
     return super.visit(method, p);
   }
 
+  /**
+   * Does this method call expression have a receiver that 1) looks like a class name, suggesting
+   * that this is a static method call, and 2) that receiver is unsolved. If both of these are true,
+   * we need to create a synthetic class for that receiver before trying to solve the other
+   * arguments.
+   *
+   * @param method a method call expr
+   * @return true iff 1 and 2 above are both true
+   */
+  private boolean hasUnsolvedReceiverLikeClassName(MethodCallExpr method) {
+    Optional<Expression> maybeReceiver = method.getScope();
+    if (!maybeReceiver.isPresent()) {
+      return false;
+    }
+    Expression receiver = maybeReceiver.get();
+    if (!isAClassPath(receiver.toString()) && !looksLikeSimpleClassName(receiver.toString())) {
+      // the receiver looks like a regular expression, not a class, so we don't need
+      // to create an additional synthetic class
+      return false;
+    }
+    try {
+      receiver.calculateResolvedType();
+      return false;
+    } catch (UnsolvedSymbolException e) {
+      return true;
+    }
+  }
+
   @Override
   public Visitable visit(EnumConstantDeclaration expr, Void p) {
     // this is a bit hacky, but we don't remove any enum constant declarations if they are ever
@@ -2186,11 +2254,12 @@ public static boolean canSolveArguments(NodeList<Expression> argList) {
       return true;
     }
     for (Expression arg : argList) {
-      if (arg.isLambdaExpr()) {
-        // Skip lambdas here and treat them specially later.
+      if (arg.isLambdaExpr() || arg.isMethodReferenceExpr()) {
+        // Skip lambdas and method refs here and treat them specially later.
         continue;
       }
       if (!canBeSolved(arg)) {
+        System.out.println("could not solve: " + arg);
         return false;
       }
     }
@@ -2280,6 +2349,12 @@ private List<String> getArgumentTypesImpl(
         LambdaExpr lambda = arg.asLambdaExpr();
         parametersList.add(resolveLambdaType(lambda, pkgName));
         continue;
+      } else if (arg.isMethodReferenceExpr()) {
+        // TODO: is there a better way to handle this? How should we know
+        // what the type is? The method ref is sometimes not solvable here.
+        // Maybe we will need to handle this in JavaTypeCorrect?
+        parametersList.add("java.util.function.Supplier<?>");
+        continue;
       }
 
       ResolvedType type = arg.calculateResolvedType();
@@ -2449,6 +2524,7 @@ public static boolean calledByAnUnsolvedSymbol(MethodCallExpr method) {
    * @return true if the expression can be solved
    */
   public static boolean canBeSolved(Expression expr) {
+    System.out.println("checking if " + expr + " is solvable");
 
     // The method calculateResolvedType() gets lazy and lacks precision when it comes to handling
     // ObjectCreationExpr instances, thus requiring separate treatment for ObjectCreationExpr.
@@ -2474,8 +2550,10 @@ public static boolean canBeSolved(Expression expr) {
           bound.getType().asReferenceType();
         }
       }
+      System.out.println("solvable");
       return true;
     } catch (Exception e) {
+      System.out.println("not solvable, because " + e);
       return false;
     }
   }
diff --git a/src/test/resources/methodref2/expected/com/example/Simple.java b/src/test/resources/methodref2/expected/com/example/Simple.java
index 3a35e628..3cf9bdb5 100644
--- a/src/test/resources/methodref2/expected/com/example/Simple.java
+++ b/src/test/resources/methodref2/expected/com/example/Simple.java
@@ -1,13 +1,15 @@
 package com.example;
 
+import java.util.Map;
+import java.util.List;
+
+import org.plumelib.util.CollectionsPlume;
+
 class Simple {
 
-    void bar() {
-        Object obj = new Object();
-        obj = baz(obj);
-    }
+    Map<MethodSignature, MethodSignature> replacementMap;
 
-    Object baz(Object obj) {
-        throw new Error();
+    void bar() {
+        List<String> signatureList = CollectionsPlume.mapList(MethodSignature::toString, replacementMap.keySet());
     }
 }

From 55373e87e79bd755b82b2545bbb55d1c095a3bea Mon Sep 17 00:00:00 2001
From: Martin Kellogg <martin.kellogg@njit.edu>
Date: Fri, 17 May 2024 10:29:31 -0400
Subject: [PATCH 04/10] formatting and remove debug logging

---
 .../checkerframework/specimin/JavaTypeCorrect.java   |  1 -
 .../checkerframework/specimin/SpeciminRunner.java    |  5 -----
 .../specimin/UnsolvedSymbolVisitor.java              | 12 ------------
 3 files changed, 18 deletions(-)

diff --git a/src/main/java/org/checkerframework/specimin/JavaTypeCorrect.java b/src/main/java/org/checkerframework/specimin/JavaTypeCorrect.java
index 30295a89..01541c05 100644
--- a/src/main/java/org/checkerframework/specimin/JavaTypeCorrect.java
+++ b/src/main/java/org/checkerframework/specimin/JavaTypeCorrect.java
@@ -257,7 +257,6 @@ public void runJavacAndUpdateTypes(String filePath) {
           }
         }
       }
-      System.out.println("error messages from javac: " + lines);
     } catch (IOException e) {
       // TODO: Handle this properly
       System.out.println(e);
diff --git a/src/main/java/org/checkerframework/specimin/SpeciminRunner.java b/src/main/java/org/checkerframework/specimin/SpeciminRunner.java
index 20156ad0..79a523ce 100644
--- a/src/main/java/org/checkerframework/specimin/SpeciminRunner.java
+++ b/src/main/java/org/checkerframework/specimin/SpeciminRunner.java
@@ -271,8 +271,6 @@ private static void performMinimizationImpl(
               addMissingClass.getAddedTargetFiles(),
               addMissingClass.getSyntheticClassesAsAStringSet());
 
-      System.out.println("current state: " + workDoneAfterIteration);
-
       // Infinite loop protection.
       boolean gettingStuck = previousIterations.contains(workDoneAfterIteration);
       if (gettingStuck) {
@@ -291,9 +289,6 @@ private static void performMinimizationImpl(
       }
       previousIterations.add(workDoneAfterIteration);
 
-      System.out.println("getting stuck? " + gettingStuck);
-      System.out.println("getting exceptions? " + addMissingClass.gettingException());
-
       if (gettingStuck || !addMissingClass.gettingException()) {
         // Three possible cases here:
         // 1: addMissingClass has finished its iteration.
diff --git a/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java b/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
index a4144e3b..ecc7339c 100644
--- a/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
+++ b/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
@@ -1072,7 +1072,6 @@ public Visitable visit(FieldAccessExpr node, Void p) {
 
   @Override
   public Visitable visit(MethodReferenceExpr node, Void p) {
-    System.out.println("visiting a method ref: " + node);
     if (insideTargetMember) {
       // TODO: handle all of the possible forms listed in JLS 15.13, not just the simplest
       Expression scope = node.getScope();
@@ -1096,8 +1095,6 @@ public Visitable visit(MethodReferenceExpr node, Void p) {
         System.err.println("Specimin warning: new in method references is not supported: " + node);
         return super.visit(node, p);
       }
-      System.out.println(
-          "adding this identifier to the list of potential used members: " + identifier);
       potentialUsedMembers.add(identifier);
     }
     return super.visit(node, p);
@@ -1110,15 +1107,12 @@ public Visitable visit(MethodCallExpr method, Void p) {
      * We ensure that the caller and its parameters are resolved before solving the method itself.
      * For instance, in a method call like a.b(c, d, e,...), we solve a, c, d, e,... before resolving b.
      */
-    System.out.println("visiting a method call: " + method);
     if (!insideTargetMember) {
-      System.out.println("1");
       return super.visit(method, p);
     }
     potentialUsedMembers.add(method.getName().asString());
     if (canBeSolved(method) && isFromAJarFile(method)) {
       updateClassesFromJarSourcesForMethodCall(method);
-      System.out.println("2");
       return super.visit(method, p);
     }
     // we will wait for the next run to solve this method call
@@ -1129,7 +1123,6 @@ public Visitable visit(MethodCallExpr method, Void p) {
         // it might prevent us from solving the rest of the arguments.
         // The receiver is guaranteed to be present by the check above.
         Expression receiver = method.getScope().orElseThrow();
-        System.out.println("triggering the special case: " + receiver);
         String typeName = receiver.toString();
         String pkgName;
         if (isAClassPath(typeName)) {
@@ -1151,7 +1144,6 @@ public Visitable visit(MethodCallExpr method, Void p) {
     if (isAnUnsolvedStaticMethodCalledByAQualifiedClassName(method)) {
       updateClassSetWithStaticMethodCall(method);
     } else if (unsolvedAndCalledByASimpleClassName(method)) {
-      System.out.println("4");
       updateClassSetWithStaticMethodCall(method);
     } else if (calledByAnIncompleteClass(method)) {
       /*
@@ -2259,7 +2251,6 @@ public static boolean canSolveArguments(NodeList<Expression> argList) {
         continue;
       }
       if (!canBeSolved(arg)) {
-        System.out.println("could not solve: " + arg);
         return false;
       }
     }
@@ -2524,7 +2515,6 @@ public static boolean calledByAnUnsolvedSymbol(MethodCallExpr method) {
    * @return true if the expression can be solved
    */
   public static boolean canBeSolved(Expression expr) {
-    System.out.println("checking if " + expr + " is solvable");
 
     // The method calculateResolvedType() gets lazy and lacks precision when it comes to handling
     // ObjectCreationExpr instances, thus requiring separate treatment for ObjectCreationExpr.
@@ -2550,10 +2540,8 @@ public static boolean canBeSolved(Expression expr) {
           bound.getType().asReferenceType();
         }
       }
-      System.out.println("solvable");
       return true;
     } catch (Exception e) {
-      System.out.println("not solvable, because " + e);
       return false;
     }
   }

From 508ca4469e9d1e32f202630c1996c69d1e174c36 Mon Sep 17 00:00:00 2001
From: Martin Kellogg <martin.kellogg@njit.edu>
Date: Fri, 17 May 2024 10:32:04 -0400
Subject: [PATCH 05/10] oops

---
 build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index c34cd1bf..e12d485a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -63,7 +63,7 @@ tasks.compileJava {
 
 checkerFramework {
     // uncomment for testing
-     skipCheckerFramework = true
+    // skipCheckerFramework = true
     checkers = [
             'org.checkerframework.checker.nullness.NullnessChecker',
             'org.checkerframework.checker.resourceleak.ResourceLeakChecker',

From 2457830ab5be98d749d2408b91c7a26fb73e6bae Mon Sep 17 00:00:00 2001
From: Martin Kellogg <martin.kellogg@njit.edu>
Date: Mon, 20 May 2024 09:06:52 -0400
Subject: [PATCH 06/10] missing files

---
 .../methodref2/expected/com/example/MethodSignature.java  | 8 ++++++++
 .../expected/org/plumelib/util/CollectionsPlume.java      | 8 ++++++++
 .../OrgPlumelibUtilCollectionsPlumeMapListReturnType.java | 4 ++++
 3 files changed, 20 insertions(+)
 create mode 100644 src/test/resources/methodref2/expected/com/example/MethodSignature.java
 create mode 100644 src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java
 create mode 100644 src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java

diff --git a/src/test/resources/methodref2/expected/com/example/MethodSignature.java b/src/test/resources/methodref2/expected/com/example/MethodSignature.java
new file mode 100644
index 00000000..3b5aba00
--- /dev/null
+++ b/src/test/resources/methodref2/expected/com/example/MethodSignature.java
@@ -0,0 +1,8 @@
+package com.example;
+
+public class MethodSignature {
+
+    public String toString() {
+        throw new Error();
+    }
+}
\ No newline at end of file
diff --git a/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java b/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java
new file mode 100644
index 00000000..17dc7a55
--- /dev/null
+++ b/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java
@@ -0,0 +1,8 @@
+package org.plumelib.util;
+
+public class CollectionsPlume {
+
+    public static OrgPlumelibUtilCollectionsPlumeMapListReturnType mapList(java.util.function.Supplier<?> parameter0, java.util.Set<?> parameter1) {
+        throw new Error();
+    }
+}
\ No newline at end of file
diff --git a/src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java b/src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java
new file mode 100644
index 00000000..0e3db04f
--- /dev/null
+++ b/src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java
@@ -0,0 +1,4 @@
+package org.plumelib.util;
+
+public class OrgPlumelibUtilCollectionsPlumeMapListReturnType {
+}
\ No newline at end of file

From 1c53ed2cf7aa014ae5fa8d2db75dc4a43d488171 Mon Sep 17 00:00:00 2001
From: Martin Kellogg <martin.kellogg@njit.edu>
Date: Mon, 20 May 2024 09:22:04 -0400
Subject: [PATCH 07/10] remove unnecessary code

---
 .../specimin/UnsolvedSymbolVisitor.java       | 46 -------------------
 1 file changed, 46 deletions(-)

diff --git a/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java b/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
index 93fee4b8..d2d7e20c 100644
--- a/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
+++ b/src/main/java/org/checkerframework/specimin/UnsolvedSymbolVisitor.java
@@ -1117,24 +1117,6 @@ public Visitable visit(MethodCallExpr method, Void p) {
     }
     // we will wait for the next run to solve this method call
     if (!canSolveArguments(method.getArguments())) {
-      if (hasUnsolvedReceiverLikeClassName(method)) {
-        // Make sure that we try to solve the receiver first if
-        // it looks like a class name and is unsolved, because otherwise
-        // it might prevent us from solving the rest of the arguments.
-        // The receiver is guaranteed to be present by the check above.
-        Expression receiver = method.getScope().orElseThrow();
-        String typeName = receiver.toString();
-        String pkgName;
-        if (isAClassPath(typeName)) {
-          pkgName = typeName.substring(0, typeName.lastIndexOf('.'));
-          typeName = typeName.substring(typeName.lastIndexOf('.') + 1);
-        } else {
-          pkgName = getPackageFromClassName(typeName);
-        }
-        UnsolvedClassOrInterface receiverClass = new UnsolvedClassOrInterface(typeName, pkgName);
-        updateMissingClass(receiverClass);
-        this.gotException();
-      }
       return super.visit(method, p);
     }
     if (isASuperCall(method) && !canBeSolved(method)) {
@@ -1197,34 +1179,6 @@ public Visitable visit(MethodCallExpr method, Void p) {
     return super.visit(method, p);
   }
 
-  /**
-   * Does this method call expression have a receiver that 1) looks like a class name, suggesting
-   * that this is a static method call, and 2) that receiver is unsolved. If both of these are true,
-   * we need to create a synthetic class for that receiver before trying to solve the other
-   * arguments.
-   *
-   * @param method a method call expr
-   * @return true iff 1 and 2 above are both true
-   */
-  private boolean hasUnsolvedReceiverLikeClassName(MethodCallExpr method) {
-    Optional<Expression> maybeReceiver = method.getScope();
-    if (!maybeReceiver.isPresent()) {
-      return false;
-    }
-    Expression receiver = maybeReceiver.get();
-    if (!isAClassPath(receiver.toString()) && !looksLikeSimpleClassName(receiver.toString())) {
-      // the receiver looks like a regular expression, not a class, so we don't need
-      // to create an additional synthetic class
-      return false;
-    }
-    try {
-      receiver.calculateResolvedType();
-      return false;
-    } catch (UnsolvedSymbolException e) {
-      return true;
-    }
-  }
-
   @Override
   public Visitable visit(EnumConstantDeclaration expr, Void p) {
     // this is a bit hacky, but we don't remove any enum constant declarations if they are ever

From 1ed273ba80bd21efb8c1324e3dc08adb1953f1bd Mon Sep 17 00:00:00 2001
From: Martin Kellogg <martin.kellogg@njit.edu>
Date: Wed, 22 May 2024 11:25:10 -0400
Subject: [PATCH 08/10] a more boring but less likely not to compile target
 type

---
 .../expected/org/plumelib/util/CollectionsPlume.java          | 2 +-
 .../OrgPlumelibUtilCollectionsPlumeMapListReturnType.java     | 4 ----
 2 files changed, 1 insertion(+), 5 deletions(-)
 delete mode 100644 src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java

diff --git a/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java b/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java
index 17dc7a55..2cd886ed 100644
--- a/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java
+++ b/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java
@@ -2,7 +2,7 @@
 
 public class CollectionsPlume {
 
-    public static OrgPlumelibUtilCollectionsPlumeMapListReturnType mapList(java.util.function.Supplier<?> parameter0, java.util.Set<?> parameter1) {
+    public static java.util.List<String> mapList(java.util.function.Function<com.example.MethodSignature, java.lang.String> parameter0, java.util.Set<com.example.MethodSignature> parameter1) {
         throw new Error();
     }
 }
\ No newline at end of file
diff --git a/src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java b/src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java
deleted file mode 100644
index 0e3db04f..00000000
--- a/src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package org.plumelib.util;
-
-public class OrgPlumelibUtilCollectionsPlumeMapListReturnType {
-}
\ No newline at end of file

From 3f127e65c97da0720f044f6f1a050c7abaae9979 Mon Sep 17 00:00:00 2001
From: Martin Kellogg <martin.kellogg@njit.edu>
Date: Wed, 22 May 2024 12:42:12 -0400
Subject: [PATCH 09/10] exempt this test from compilation

---
 typecheck_test_outputs.sh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/typecheck_test_outputs.sh b/typecheck_test_outputs.sh
index 8aeb8c8a..a76958d5 100755
--- a/typecheck_test_outputs.sh
+++ b/typecheck_test_outputs.sh
@@ -14,6 +14,9 @@ for testcase in * ; do
     if [ "${testcase}" = "shared" ]; then continue; fi
     # https://bugs.openjdk.org/browse/JDK-8319461 wasn't actually fixed (this test is based on that bug)
     if [ "${testcase}" = "superinterfaceextends" ]; then continue; fi
+    # incomplete handling of method references: https://github.com/njit-jerse/specimin/issues/291
+    # this test exists to check that no crash occurs, not that Specimin produces the correct output
+    if [ "${testcase}" = "methodref2" ]; then continue; fi
     cd "${testcase}/expected/" || exit 1
     # javac relies on word splitting
     # shellcheck disable=SC2046

From f1627e2b9c56f72a2fbe78a9ee2be1ea1c579185 Mon Sep 17 00:00:00 2001
From: Martin Kellogg <martin.kellogg@njit.edu>
Date: Wed, 22 May 2024 12:43:13 -0400
Subject: [PATCH 10/10] Revert "a more boring but less likely not to compile
 target type"

This reverts commit 1ed273ba80bd21efb8c1324e3dc08adb1953f1bd.
---
 .../expected/org/plumelib/util/CollectionsPlume.java          | 2 +-
 .../OrgPlumelibUtilCollectionsPlumeMapListReturnType.java     | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)
 create mode 100644 src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java

diff --git a/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java b/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java
index 2cd886ed..17dc7a55 100644
--- a/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java
+++ b/src/test/resources/methodref2/expected/org/plumelib/util/CollectionsPlume.java
@@ -2,7 +2,7 @@
 
 public class CollectionsPlume {
 
-    public static java.util.List<String> mapList(java.util.function.Function<com.example.MethodSignature, java.lang.String> parameter0, java.util.Set<com.example.MethodSignature> parameter1) {
+    public static OrgPlumelibUtilCollectionsPlumeMapListReturnType mapList(java.util.function.Supplier<?> parameter0, java.util.Set<?> parameter1) {
         throw new Error();
     }
 }
\ No newline at end of file
diff --git a/src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java b/src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java
new file mode 100644
index 00000000..0e3db04f
--- /dev/null
+++ b/src/test/resources/methodref2/expected/org/plumelib/util/OrgPlumelibUtilCollectionsPlumeMapListReturnType.java
@@ -0,0 +1,4 @@
+package org.plumelib.util;
+
+public class OrgPlumelibUtilCollectionsPlumeMapListReturnType {
+}
\ No newline at end of file