Remove unnecessary resolution attempts in modules when solving symbols as values

johannescoetzee · johannescoetzee · commit b811a9cf2dd4 · 2026-01-06T16:40:50.000+01:00
diff --git a/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ClassOrInterfaceDeclarationContext.java b/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ClassOrInterfaceDeclarationContext.java
@@ -67,15 +67,6 @@ public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String na
             return SymbolReference.solved(this.getDeclaration().getVisibleField(name));
         }
 
-        // Compact classes implicitly import the java.base module. To avoid having to add this import explicitly,
-        // first check if the class is compact and then try to solve the given type in the java.base module.
-        if (wrappedNode.isCompact()) {
-            SymbolReference<ResolvedValueDeclaration> maybeSolved = solveInJavaBaseModule(name);
-            if (maybeSolved.isSolved()) {
-                return maybeSolved;
-            }
-        }
-
         // then to parent
         return solveSymbolInParentContext(name);
     }
@@ -88,33 +79,10 @@ public Optional<Value> solveSymbolAsValue(String name) {
             return Optional.of(Value.from(this.getDeclaration().getField(name)));
         }
 
-        // Compact classes implicitly import the java.base module. To avoid having to add this import explicitly,
-        // first check if the class is compact and then try to solve the given type in the java.base module.
-        if (wrappedNode.isCompact()) {
-            SymbolReference<ResolvedValueDeclaration> maybeSolved = solveInJavaBaseModule(name);
-            if (maybeSolved.isSolved()) {
-                return Optional.of(Value.from(maybeSolved.getCorrespondingDeclaration()));
-            }
-        }
-
         // then to parent
         return solveSymbolAsValueInParentContext(name);
     }
 
-    /**
-     * Compact classes implicitly import the java.base module, so when resolving a type in a compact class
-     * this needs to be checked.
-     */
-    private SymbolReference<ResolvedValueDeclaration> solveInJavaBaseModule(String name) {
-        SymbolReference<ResolvedReferenceTypeDeclaration> maybeSolved =
-                typeSolver.tryToSolveTypeInModule(JAVA_BASE_MODULE_NAME, name);
-        if (maybeSolved.isSolved() && maybeSolved.getDeclaration().get() instanceof ResolvedValueDeclaration) {
-            return SymbolReference.solved(
-                    (ResolvedValueDeclaration) maybeSolved.getDeclaration().get());
-        }
-        return SymbolReference.unsolved();
-    }
-
     @Override
     public Optional<ResolvedType> solveGenericType(String name) {
         // First check if the method-like declaration has type parameters defined.
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserVariableDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserVariableDeclarationTest.java
@@ -30,6 +30,7 @@
 import com.github.javaparser.ParserConfiguration;
 import com.github.javaparser.ast.CompilationUnit;
 import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
 import com.github.javaparser.ast.body.VariableDeclarator;
 import com.github.javaparser.ast.expr.NameExpr;
 import com.github.javaparser.resolution.declarations.AssociableToAST;
@@ -170,4 +171,35 @@ void javaBaseTypeFromImplicitCompactClassImport() {
                 "java.util.List<java.lang.String>",
                 declarator.getType().resolve().describe());
     }
+
+    @Test
+    @EnabledForJreRange(min = JRE.JAVA_9)
+    void javaBaseTypeFromImplicitCompactClassImportSolvedAsSymbol() {
+        String code = "List<String> l; void main() { l = new ArrayList<>(); }";
+
+        ReflectionTypeSolver typeSolver = new ReflectionTypeSolver();
+        ParserConfiguration parserConfiguration = new ParserConfiguration()
+                .setLanguageLevel(ParserConfiguration.LanguageLevel.JAVA_25)
+                .setSymbolResolver(new JavaSymbolSolver(typeSolver));
+        JavaParser parser = new JavaParser(parserConfiguration);
+
+        ParseResult<CompilationUnit> parseResult = parser.parse(code);
+
+        assertTrue(parseResult.isSuccessful());
+
+        CompilationUnit cu = parseResult.getResult().get();
+
+        ClassOrInterfaceDeclaration compactClass =
+                cu.findFirst(ClassOrInterfaceDeclaration.class).get();
+
+        JavaParserClassDeclaration resolvedClass = (JavaParserClassDeclaration) compactClass.resolve();
+
+        assertEquals(
+                "java.util.List<java.lang.String>",
+                resolvedClass
+                        .solveSymbol("l", typeSolver)
+                        .getCorrespondingDeclaration()
+                        .getType()
+                        .describe());
+    }
 }
