assume unfound classes to be in the same package as the current class

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

@@ -526,13 +526,9 @@ public Visitable visit(MethodDeclaration node, Void arg) {
       try {
         nodeType.resolve();
       } catch (UnsolvedSymbolException | UnsupportedOperationException e) {
-        if (classAndPackageMap.containsKey(nodeTypeSimpleForm)) {
-          UnsolvedClass syntheticType =
-              new UnsolvedClass(nodeTypeSimpleForm, classAndPackageMap.get(nodeTypeSimpleForm));
-          this.updateMissingClass(syntheticType);
-        } else {
-          throw new RuntimeException("Unexpected class: " + nodeTypeSimpleForm);
-        }
+        // 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.
+        this.updateMissingClass(createUnsolvedClass(nodeTypeSimpleForm));
       }
     }
 
@@ -677,12 +673,7 @@ public Visitable visit(Parameter parameter, Void p) {
       } else {
         // since it is unsolved, it could not be a primitive type
         @ClassGetSimpleName String className = parameter.getType().asClassOrInterfaceType().getName().asString();
-        if (classAndPackageMap.containsKey(className)) {
-          UnsolvedClass newClass = new UnsolvedClass(className, classAndPackageMap.get(className));
-          updateMissingClass(newClass);
-        } else {
-          throw new RuntimeException("Unexpected class: " + className);
-        }
+        updateMissingClass(createUnsolvedClass(className));
       }
     }
     gotException = true;
@@ -706,14 +697,12 @@ public Visitable visit(ObjectCreationExpr newExpr, Void p) {
     try {
       List<String> argumentsCreation = getArgumentsFromObjectCreation(newExpr);
       UnsolvedMethod creationMethod = new UnsolvedMethod("", type, argumentsCreation);
-      if (classAndPackageMap.containsKey(type)) {
-        UnsolvedClass newClass = new UnsolvedClass(type, classAndPackageMap.get(type));
-        newClass.addMethod(creationMethod);
-        this.updateMissingClass(newClass);
-      } else {
-        throw new RuntimeException("Unexpected class: " + type);
-      }
-
+      // 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);
     } catch (Exception q) {
       // can not solve the parameters for this object creation in this current run
     }
@@ -807,10 +796,9 @@ public void updateUnsolvedClassWithMethod(
     } else {
       returnType = desiredReturnType;
     }
-    if (!classAndPackageMap.containsKey(className)) {
-      throw new RuntimeException("Unexpected class: " + className);
-    }
-    UnsolvedClass missingClass = new UnsolvedClass(className, classAndPackageMap.get(className));
+    // 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);
     missingClass.addMethod(thisMethod);
     syntheticMethodAndClass.put(methodName, missingClass);
@@ -889,6 +877,20 @@ public void updateClassesFromJarSourcesForMethodCall(MethodCallExpr expr) {
     this.updateMissingClass(missingClass);
   }
 
+  /**
+   * Given the simple name of an unsolved class, this method will create an UnsolvedClass instance
+   * to represent that class.
+   *
+   * @param nameOfClass the name of an unsolved class
+   * @return an UnsolvedClass instance
+   */
+  public UnsolvedClass createUnsolvedClass(@ClassGetSimpleName String nameOfClass) {
+    // 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);
+    return new UnsolvedClass(nameOfClass, packageName);
+  }
+
   /**
    * This method updates a synthetic file based on a solvable expression. The input expression is
    * solvable because its data is in the jar files that Specimin taks as input.

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

@@ -0,0 +1,18 @@
+package org.checkerframework.specimin;
+
+import java.io.IOException;
+import org.junit.Test;
+
+/**
+ * This test checks that if there is an unsolved class not present among import statements, Specimin
+ * will assume that the class is in the same directory as the current class.
+ */
+public class UnsolvedClassInSamePackageTest {
+  @Test
+  public void runTest() throws IOException {
+    SpeciminTestExecutor.runTestWithoutJarPaths(
+        "unsolvedclassinsamepackage",
+        new String[] {"com/example/Simple.java"},
+        new String[] {"com.example.Simple#bar()"});
+  }
+}

src/test/resources/unsolvedclassinsamepackage/expected/com/example/Baz.java

@@ -0,0 +1,8 @@
+package com.example;
+
+public class Baz {
+
+    public Baz(java.lang.String parameter0) {
+        throw new Error();
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.example;
+
+class Simple {
+
+    void bar() {
+        Baz obj = new Baz("hello");
+    }
+}

src/test/resources/unsolvedclassinsamepackage/input/com/example/Simple.java

@@ -0,0 +1,7 @@
+package com.example;
+
+class Simple {
+    void bar() {
+        Baz obj = new Baz("hello");
+    }
+}