From e02a89d88a5fb857a49ea4b8b21d2d6bfcc076ae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Aur=C3=A9lien=20Coet?= Date: Mon, 2 Nov 2026 13:22:57 +0100 Subject: [PATCH 1/2] Switch the existing J parser and semantic classes to PSI --- .../internal/InternalCheckVerifierTest.java | 12 + .../org/eclipse/jdt/core/dom/ASTUtils.java | 132 - .../eclipse/jdt/core/dom/package-info.java | 17 - .../org/sonar/java/ast/JavaAstScanner.java | 6 +- .../java/model/EcjDiagnosticProvider.java | 67 - .../sonar/java/model/EcjFrontendBackend.java | 96 - .../sonar/java/model/EcjProgressMonitor.java | 69 - .../java/model/EcjSemanticAttachment.java | 48 - .../sonar/java/model/EcjSymbolMetadata.java | 112 - .../org/sonar/java/model/EcjTreeBindings.java | 103 - .../org/sonar/java/model/JMethodSymbol.java | 253 +- .../org/sonar/java/model/JPackageSymbol.java | 23 +- .../java/org/sonar/java/model/JParser.java | 3747 +++++------------ .../org/sonar/java/model/JParserConfig.java | 21 +- .../main/java/org/sonar/java/model/JSema.java | 452 +- .../java/org/sonar/java/model/JSymbol.java | 455 +- .../org/sonar/java/model/JSymbolMetadata.java | 109 + .../main/java/org/sonar/java/model/JType.java | 417 +- .../org/sonar/java/model/JTypeSymbol.java | 293 +- .../org/sonar/java/model/JVariableSymbol.java | 218 +- .../sonar/java/model/LineColumnConverter.java | 9 +- .../sonar/java/model/PsiFrontendBackend.java | 119 + .../java/model/PsiSemanticAttachment.java | 359 ++ .../org/sonar/java/model/VisitorsBridge.java | 6 +- .../model/expression/InstanceOfTreeImpl.java | 3 - .../plugins/java/api/semantic/Symbol.java | 2 +- .../eclipse/jdt/core/dom/ASTUtilsTest.java | 29 - .../java/org/sonar/java/JavaFrontendTest.java | 18 + .../org/sonar/java/ProgressMonitorTest.java | 3 +- .../sonar/java/ast/JavaAstScannerTest.java | 20 +- .../sonar/java/model/ClassesLayoutTest.java | 12 +- .../org/sonar/java/model/EcjTestSupport.java | 77 - .../java/model/FrontendLifecycleTest.java | 4 +- .../sonar/java/model/JMethodSymbolTest.java | 137 +- .../sonar/java/model/JParserConfigTest.java | 18 + .../java/model/JParserConversionTest.java | 176 + .../sonar/java/model/JParserSemanticTest.java | 599 ++- .../org/sonar/java/model/JParserTest.java | 122 +- .../sonar/java/model/JSemaRegressionTest.java | 244 ++ .../java/org/sonar/java/model/JSemaTest.java | 34 +- .../org/sonar/java/model/JSymbolTest.java | 187 +- .../org/sonar/java/model/JTypeSymbolTest.java | 75 +- .../java/org/sonar/java/model/JTypeTest.java | 87 +- .../java/org/sonar/java/model/JUtilsTest.java | 54 +- .../sonar/java/model/JavaTreeModelTest.java | 3 - .../sonar/java/model/KeywordSuperTest.java | 4 +- .../org/sonar/java/model/KeywordThisTest.java | 4 +- .../java/model/PsiFrontendBackendTest.java | 249 ++ .../java/model/PsiSemanticTestSupport.java | 80 + .../sonar/java/model/PsiSyntaxCorpusTest.java | 72 + .../java/model/PsiSyntaxTestSupport.java | 102 + .../java/model/SemanticCompatibilityTest.java | 203 + .../org/sonar/java/model/SemanticFixture.java | 10 +- .../sonar/java/model/SemanticTestSupport.java | 134 + .../org/sonar/java/model/SymbolsTest.java | 5 +- .../model/declaration/ClassTreeImplTest.java | 2 +- .../utils/JavaFileTypeClassifierTest.java | 8 +- .../sonar/plugins/java/JavaSensorTest.java | 2 + 58 files changed, 4593 insertions(+), 5329 deletions(-) delete mode 100644 java-frontend/src/main/java/org/eclipse/jdt/core/dom/ASTUtils.java delete mode 100644 java-frontend/src/main/java/org/eclipse/jdt/core/dom/package-info.java delete mode 100644 java-frontend/src/main/java/org/sonar/java/model/EcjDiagnosticProvider.java delete mode 100644 java-frontend/src/main/java/org/sonar/java/model/EcjFrontendBackend.java delete mode 100644 java-frontend/src/main/java/org/sonar/java/model/EcjProgressMonitor.java delete mode 100644 java-frontend/src/main/java/org/sonar/java/model/EcjSemanticAttachment.java delete mode 100644 java-frontend/src/main/java/org/sonar/java/model/EcjSymbolMetadata.java delete mode 100644 java-frontend/src/main/java/org/sonar/java/model/EcjTreeBindings.java create mode 100644 java-frontend/src/main/java/org/sonar/java/model/PsiFrontendBackend.java create mode 100644 java-frontend/src/main/java/org/sonar/java/model/PsiSemanticAttachment.java delete mode 100644 java-frontend/src/test/java/org/eclipse/jdt/core/dom/ASTUtilsTest.java delete mode 100644 java-frontend/src/test/java/org/sonar/java/model/EcjTestSupport.java create mode 100644 java-frontend/src/test/java/org/sonar/java/model/JParserConversionTest.java create mode 100644 java-frontend/src/test/java/org/sonar/java/model/JSemaRegressionTest.java create mode 100644 java-frontend/src/test/java/org/sonar/java/model/PsiFrontendBackendTest.java create mode 100644 java-frontend/src/test/java/org/sonar/java/model/PsiSemanticTestSupport.java create mode 100644 java-frontend/src/test/java/org/sonar/java/model/PsiSyntaxCorpusTest.java create mode 100644 java-frontend/src/test/java/org/sonar/java/model/PsiSyntaxTestSupport.java create mode 100644 java-frontend/src/test/java/org/sonar/java/model/SemanticCompatibilityTest.java create mode 100644 java-frontend/src/test/java/org/sonar/java/model/SemanticTestSupport.java diff --git a/java-checks-testkit/src/test/java/org/sonar/java/checks/verifier/internal/InternalCheckVerifierTest.java b/java-checks-testkit/src/test/java/org/sonar/java/checks/verifier/internal/InternalCheckVerifierTest.java index 9e53623b97b..ab769f724a9 100644 --- a/java-checks-testkit/src/test/java/org/sonar/java/checks/verifier/internal/InternalCheckVerifierTest.java +++ b/java-checks-testkit/src/test/java/org/sonar/java/checks/verifier/internal/InternalCheckVerifierTest.java @@ -74,6 +74,18 @@ class InternalCheckVerifierTest { + @Test + void normal_scanner_uses_selected_backend() { + CheckVerifier.newVerifier().onFile(TEST_FILE).withCheck(new JavaFileScanner() { + @Override + public void scanFile(JavaFileScannerContext context) { + var tree = (org.sonar.java.model.JavaTree.CompilationUnitTreeImpl) context.getTree(); + String expected = "JSema"; + assertThat(tree.sema.getClass().getSimpleName()).isEqualTo(expected); + } + }).verifyNoIssues(); + } + @Nested class TestingCheckVerifierInitialConfiguration { diff --git a/java-frontend/src/main/java/org/eclipse/jdt/core/dom/ASTUtils.java b/java-frontend/src/main/java/org/eclipse/jdt/core/dom/ASTUtils.java deleted file mode 100644 index 80bc65622b0..00000000000 --- a/java-frontend/src/main/java/org/eclipse/jdt/core/dom/ASTUtils.java +++ /dev/null @@ -1,132 +0,0 @@ -/* - * SonarQube Java - * Copyright (C) SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * You can redistribute and/or modify this program under the terms of - * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.eclipse.jdt.core.dom; - -import java.util.Objects; -import javax.annotation.Nullable; -import org.eclipse.jdt.core.compiler.CharOperation; -import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation; -import org.eclipse.jdt.internal.compiler.env.IBinaryType; -import org.eclipse.jdt.internal.compiler.env.INameEnvironment; -import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer; -import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding; -import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding; -import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment; -import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding; -import org.eclipse.jdt.internal.compiler.lookup.TypeConstants; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public final class ASTUtils { - - private static final Logger LOG = LoggerFactory.getLogger(ASTUtils.class); - - private static final IAnnotationBinding[] NO_ANNOTATIONS = new IAnnotationBinding[0]; - - private ASTUtils() { - } - - public static void mayTolerateMissingType(AST ast) { - ast.getBindingResolver().lookupEnvironment().mayTolerateMissingType = true; - } - - public static Runnable getEnvironmentCleaner(AST ast) { - return new EnvironmentCleaner(ast.getBindingResolver().lookupEnvironment().nameEnvironment); - } - - @Nullable - public static ITypeBinding resolveType(AST ast, String name) { - try { - BindingResolver bindingResolver = ast.getBindingResolver(); - ReferenceBinding referenceBinding = bindingResolver - .lookupEnvironment() - .getType(CharOperation.splitOn('.', name.toCharArray())); - return bindingResolver.getTypeBinding(referenceBinding); - } catch (Exception e) { - // exception on ECJ side when trying to resolve a Type, recover on null type - LOG.error("ECJ Unable to resolve type " + name, e); - return null; - } - } - - public static IAnnotationBinding[] resolvePackageAnnotations(AST ast, String packageName) { - // See org.eclipse.jdt.core.dom.PackageBinding#getAnnotations() - BindingResolver bindingResolver = ast.getBindingResolver(); - LookupEnvironment lookupEnvironment = bindingResolver.lookupEnvironment(); - NameEnvironmentAnswer answer = lookupEnvironment.nameEnvironment.findType( - TypeConstants.PACKAGE_INFO_NAME, - CharOperation.splitOn('.', packageName.toCharArray()) - ); - if (answer == null) { - return NO_ANNOTATIONS; - } - IBinaryType type = answer.getBinaryType(); - if (type == null) { - // Can happen for instance with ant, as ant only generates 'package-info.class' - // when there is annotations in the package-info.java file. - return NO_ANNOTATIONS; - } - IBinaryAnnotation[] binaryAnnotations = type.getAnnotations(); - AnnotationBinding[] binaryInstances = - BinaryTypeBinding.createAnnotations(binaryAnnotations, lookupEnvironment, type.getMissingTypeNames()); - AnnotationBinding[] allInstances = - AnnotationBinding.addStandardAnnotations(binaryInstances, type.getTagBits(), lookupEnvironment); - - IAnnotationBinding[] domInstances = new IAnnotationBinding[allInstances.length]; - for (int i = 0; i < allInstances.length; i++) { - // FIXME can be null if annotation can not be resolved e.g. due to incomplete classpath - domInstances[i] = bindingResolver.getAnnotationInstance(allInstances[i]); - } - return domInstances; - } - - public static String signature(IMethodBinding methodBinding) { - char[] signature = ((MethodBinding) methodBinding).binding.signature(); - return new String(signature); - } - - private static class EnvironmentCleaner implements Runnable { - private final INameEnvironment env; - - private EnvironmentCleaner(INameEnvironment env) { - this.env = env; - } - - @Override - public void run() { - env.cleanup(); - } - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - EnvironmentCleaner that = (EnvironmentCleaner) o; - return Objects.equals(env, that.env); - } - - @Override - public int hashCode() { - return Objects.hash(env); - } - } - -} diff --git a/java-frontend/src/main/java/org/eclipse/jdt/core/dom/package-info.java b/java-frontend/src/main/java/org/eclipse/jdt/core/dom/package-info.java deleted file mode 100644 index 41ae9dc837b..00000000000 --- a/java-frontend/src/main/java/org/eclipse/jdt/core/dom/package-info.java +++ /dev/null @@ -1,17 +0,0 @@ -/* - * SonarQube Java - * Copyright (C) SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * You can redistribute and/or modify this program under the terms of - * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.eclipse.jdt.core.dom; diff --git a/java-frontend/src/main/java/org/sonar/java/ast/JavaAstScanner.java b/java-frontend/src/main/java/org/sonar/java/ast/JavaAstScanner.java index f7bf25fb650..338cd991eed 100644 --- a/java-frontend/src/main/java/org/sonar/java/ast/JavaAstScanner.java +++ b/java-frontend/src/main/java/org/sonar/java/ast/JavaAstScanner.java @@ -30,6 +30,7 @@ import java.util.stream.StreamSupport; import javax.annotation.Nullable; import org.apache.commons.lang3.exception.ExceptionUtils; +import org.eclipse.core.runtime.OperationCanceledException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.sonar.api.batch.fs.InputFile; @@ -116,7 +117,6 @@ private void scan(Iterable inputFiles, Consumer simpleScan(i, r, - // Due to a bug in ECJ, JAR files remain locked after the analysis on Windows, we unlock them manually. See SONARJAVA-3609. JavaAstScanner::cleanUpAst, modifyCompilationUnit)); } finally { @@ -229,7 +229,9 @@ public boolean shouldFailAnalysis() { public void checkInterrupted(Exception e) { Throwable cause = ExceptionUtils.getRootCause(e); - if (cause instanceof InterruptedException + if (Thread.currentThread().isInterrupted() + || ExceptionUtils.getThrowableList(e).stream().anyMatch(OperationCanceledException.class::isInstance) + || cause instanceof InterruptedException || cause instanceof InterruptedIOException || cause instanceof CancellationException || analysisCancelled()) { diff --git a/java-frontend/src/main/java/org/sonar/java/model/EcjDiagnosticProvider.java b/java-frontend/src/main/java/org/sonar/java/model/EcjDiagnosticProvider.java deleted file mode 100644 index 4539f4241c6..00000000000 --- a/java-frontend/src/main/java/org/sonar/java/model/EcjDiagnosticProvider.java +++ /dev/null @@ -1,67 +0,0 @@ -/* - * SonarQube Java - * Copyright (C) SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * You can redistribute and/or modify this program under the terms of - * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.java.model; - -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.Set; -import java.util.stream.Stream; -import org.eclipse.jdt.core.JavaCore; -import org.eclipse.jdt.core.compiler.IProblem; -import org.eclipse.jdt.core.dom.CompilationUnit; - -final class EcjDiagnosticProvider { - - private static final Map IDS = Map.of( - JProblem.Type.UNDEFINED_TYPE, IProblem.UndefinedType, - JProblem.Type.PREVIEW_FEATURE_USED, IProblem.PreviewFeatureUsed, - JProblem.Type.UNUSED_IMPORT, IProblem.UnusedImport, - JProblem.Type.REDUNDANT_CAST, IProblem.UnnecessaryCast, - JProblem.Type.ASSIGNMENT_HAS_NO_EFFECT, IProblem.AssignmentHasNoEffect, - JProblem.Type.MASKED_CATCH, IProblem.MaskedCatch); - - private EcjDiagnosticProvider() { - } - - static Set compilerOptions() { - return Set.of( - JavaCore.COMPILER_PB_UNUSED_IMPORT, - JavaCore.COMPILER_PB_UNNECESSARY_TYPE_CHECK, - JavaCore.COMPILER_PB_NO_EFFECT_ASSIGNMENT, - JavaCore.COMPILER_PB_HIDDEN_CATCH_BLOCK - ); - } - - static List warnings(CompilationUnit ast, LineColumnConverter positions) { - return Stream.of(ast.getProblems()) - .map(problem -> convert(problem, positions)) - .filter(Objects::nonNull) - .toList(); - } - - private static JWarning convert(IProblem problem, LineColumnConverter positions) { - for (JProblem.Type type : JProblem.Type.values()) { - if (problem.getID() == IDS.get(type)) { - LineColumnConverter.Pos start = positions.toPos(problem.getSourceStart()); - LineColumnConverter.Pos end = positions.toPos(problem.getSourceStart()); - return new JWarning(problem.getMessage(), type, start.line(), start.columnOffset(), end.line(), end.columnOffset()); - } - } - return null; - } -} diff --git a/java-frontend/src/main/java/org/sonar/java/model/EcjFrontendBackend.java b/java-frontend/src/main/java/org/sonar/java/model/EcjFrontendBackend.java deleted file mode 100644 index 9b36a94bd77..00000000000 --- a/java-frontend/src/main/java/org/sonar/java/model/EcjFrontendBackend.java +++ /dev/null @@ -1,96 +0,0 @@ -/* - * SonarQube Java - * Copyright (C) SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * You can redistribute and/or modify this program under the terms of - * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.java.model; - -import java.io.File; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.function.BiConsumer; -import java.util.function.Supplier; -import org.eclipse.jdt.core.JavaCore; -import org.eclipse.jdt.core.dom.AST; -import org.eclipse.jdt.core.dom.ASTParser; -import org.eclipse.jdt.core.dom.ASTUtils; -import org.eclipse.jdt.core.dom.CompilationUnit; -import org.eclipse.jdt.core.dom.FileASTRequestor; -import org.sonar.api.batch.fs.InputFile; -import org.sonar.java.ProgressMonitor; - -final class EcjFrontendBackend implements FrontendBackend { - - private final Supplier parserFactory; - - EcjFrontendBackend(Supplier parserFactory) { - this.parserFactory = parserFactory; - } - - @Override - public FrontendSession open(FrontendConfiguration configuration) { - return new Session(configuration, parserFactory.get()); - } - - static ASTParser newParser(FrontendConfiguration configuration) { - ASTParser parser = ASTParser.newParser(AST.getJLSLatest()); - Map options = new HashMap<>(JavaCore.getOptions()); - JavaCore.setComplianceOptions(configuration.sourceVersion(), options); - options.put(JavaCore.COMPILER_PB_MAX_PER_UNIT, "42000"); - if (configuration.ignoreUnnamedModuleForSplitPackage()) { - options.put(JavaCore.COMPILER_IGNORE_UNNAMED_MODULE_FOR_SPLIT_PACKAGE, "enabled"); - } - if (configuration.previewEnabled()) { - options.put(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, "enabled"); - } - EcjDiagnosticProvider.compilerOptions().forEach(option -> options.put(option, "warning")); - parser.setCompilerOptions(options); - boolean includeRunningVMBootclasspath = configuration.classpath().stream() - .noneMatch(file -> Set.of("rt.jar", "jrt-fs.jar", "android.jar").contains(file.getName())); - parser.setEnvironment(configuration.classpath().stream().map(File::getAbsolutePath).toArray(String[]::new), - new String[] {}, new String[] {}, includeRunningVMBootclasspath); - parser.setResolveBindings(true); - parser.setBindingsRecovery(true); - return parser; - } - - private static final class Session extends FrontendSession { - - private final FrontendConfiguration configuration; - private final ASTParser parser; - - private Session(FrontendConfiguration configuration, ASTParser parser) { - this.configuration = configuration; - this.parser = parser; - } - - @Override - JavaTree.CompilationUnitTreeImpl parse(String unitName, String source) { - return JParser.parse(parser, configuration.sourceVersion(), unitName, source, ast -> own(ASTUtils.getEnvironmentCleaner(ast.getAST()))); - } - - @Override - void parseBatch(FrontendBatch inputs, ProgressMonitor monitor, BiConsumer action) { - parser.createASTs(inputs.paths().toArray(String[]::new), inputs.encodings().toArray(String[]::new), new String[0], new FileASTRequestor() { - @Override - public void acceptAST(String sourceFilePath, CompilationUnit ast) { - Runnable cleaner = own(ASTUtils.getEnvironmentCleaner(ast.getAST())); - InputFile input = inputs.byPath().get(new File(sourceFilePath)); - action.accept(input, () -> JParser.convert(configuration.sourceVersion(), input.filename(), input.contents(), ast, cleaner)); - } - }, new EcjProgressMonitor(monitor)); - } - } -} diff --git a/java-frontend/src/main/java/org/sonar/java/model/EcjProgressMonitor.java b/java-frontend/src/main/java/org/sonar/java/model/EcjProgressMonitor.java deleted file mode 100644 index 2622e6bcb0b..00000000000 --- a/java-frontend/src/main/java/org/sonar/java/model/EcjProgressMonitor.java +++ /dev/null @@ -1,69 +0,0 @@ -/* - * SonarQube Java - * Copyright (C) SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * You can redistribute and/or modify this program under the terms of - * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.java.model; - -import org.eclipse.core.runtime.IProgressMonitor; -import org.sonar.java.ProgressMonitor; - -final class EcjProgressMonitor implements IProgressMonitor { - - private final ProgressMonitor delegate; - - EcjProgressMonitor(ProgressMonitor delegate) { - this.delegate = delegate; - } - - @Override - public void beginTask(String name, int totalWork) { - delegate.beginTask(name, totalWork); - } - - @Override - public void done() { - delegate.done(); - } - - @Override - public void worked(int work) { - delegate.worked(work); - } - - @Override - public boolean isCanceled() { - return delegate.isCanceled(); - } - - @Override - public void setCanceled(boolean value) { - delegate.setCanceled(value); - } - - @Override - public void internalWorked(double work) { - delegate.internalWorked(work); - } - - @Override - public void setTaskName(String name) { - delegate.setTaskName(name); - } - - @Override - public void subTask(String name) { - delegate.subTask(name); - } -} diff --git a/java-frontend/src/main/java/org/sonar/java/model/EcjSemanticAttachment.java b/java-frontend/src/main/java/org/sonar/java/model/EcjSemanticAttachment.java deleted file mode 100644 index 4b586b9989b..00000000000 --- a/java-frontend/src/main/java/org/sonar/java/model/EcjSemanticAttachment.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * SonarQube Java - * Copyright (C) SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * You can redistribute and/or modify this program under the terms of - * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.java.model; - -import java.util.Objects; -import java.util.function.Function; -import java.util.function.Supplier; -import javax.annotation.Nullable; -import org.eclipse.jdt.core.dom.IBinding; - -final class EcjSemanticAttachment implements Supplier { - - final B binding; - private final Function factory; - private T value; - - EcjSemanticAttachment(B binding, Function factory) { - this.binding = binding; - this.factory = factory; - } - - @Override - public T get() { - if (value == null) { - value = Objects.requireNonNull(factory.apply(binding)); - } - return value; - } - - @Nullable - static IBinding getBinding(Supplier attachment) { - return attachment instanceof EcjSemanticAttachment ecj ? ecj.binding : null; - } -} diff --git a/java-frontend/src/main/java/org/sonar/java/model/EcjSymbolMetadata.java b/java-frontend/src/main/java/org/sonar/java/model/EcjSymbolMetadata.java deleted file mode 100644 index 8e97a4f7005..00000000000 --- a/java-frontend/src/main/java/org/sonar/java/model/EcjSymbolMetadata.java +++ /dev/null @@ -1,112 +0,0 @@ -/* - * SonarQube Java - * Copyright (C) SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * You can redistribute and/or modify this program under the terms of - * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.java.model; - -import java.util.Arrays; -import java.util.List; -import java.util.stream.Collectors; -import org.eclipse.jdt.core.dom.IAnnotationBinding; -import org.eclipse.jdt.core.dom.ITypeBinding; -import org.eclipse.jdt.core.dom.IVariableBinding; -import org.sonar.plugins.java.api.semantic.Symbol; -import org.sonar.plugins.java.api.semantic.SymbolMetadata.AnnotationInstance; -import org.sonar.plugins.java.api.semantic.SymbolMetadata.AnnotationValue; - -final class EcjSymbolMetadata { - - private EcjSymbolMetadata() { - } - - static JSymbolMetadata declaration(JSema sema, Symbol owner, IAnnotationBinding[] bindings) { - return metadata(sema, owner, bindings, new JSymbolMetadata[0], false); - } - - static JSymbolMetadata of(JSema sema, Symbol owner, ITypeBinding type, IAnnotationBinding[] externalAnnotations) { - var symbolAnnotations = new IAnnotationBinding[externalAnnotations.length + type.getTypeAnnotations().length]; - System.arraycopy(externalAnnotations, 0, symbolAnnotations, 0, externalAnnotations.length); - System.arraycopy(type.getTypeAnnotations(), 0, symbolAnnotations, externalAnnotations.length, type.getTypeAnnotations().length); - - var parameterMetaDatas = Arrays.stream(type.getTypeArguments()) - .map(param -> ofTypeArg(sema, owner, param)) - .toArray(JSymbolMetadata[]::new); - - return metadata(sema, owner, symbolAnnotations, parameterMetaDatas, false); - } - - private static JSymbolMetadata ofTypeArg(JSema sema, Symbol owner, ITypeBinding param) { - var symbolAnnotations = param.getTypeAnnotations(); - var parameterMetaDatas = Arrays.stream(param.getTypeArguments()) - .map(p -> ofTypeArg(sema, owner, p)) - .toArray(JSymbolMetadata[]::new); - return metadata(sema, owner, symbolAnnotations, parameterMetaDatas, true); - } - - private static JSymbolMetadata metadata(JSema sema, Symbol owner, IAnnotationBinding[] bindings, - JSymbolMetadata[] parameters, boolean typeArgument) { - return new JSymbolMetadata(owner, () -> Arrays.stream(bindings).map(sema::annotation).collect(Collectors.toList()), parameters, typeArgument); - } - - static final class JAnnotationInstance implements AnnotationInstance { - private final JSema sema; - private final IAnnotationBinding annotationBinding; - - /** - * Cache for {@link #values()}. - */ - private List values; - - JAnnotationInstance(JSema sema, IAnnotationBinding annotationBinding) { - this.sema = sema; - this.annotationBinding = annotationBinding; - } - - @Override - public Symbol symbol() { - return sema.typeSymbol(annotationBinding.getAnnotationType()); - } - - @Override - public List values() { - if (values == null) { - values = Arrays.stream(annotationBinding.getDeclaredMemberValuePairs()) - .map(p -> new AnnotationValueImpl(p.getName(), convertAnnotationValue(p.getValue()))) - .collect(Collectors.toList()); - } - return values; - } - - private Object convertAnnotationValue(Object value) { - return EcjSymbolMetadata.convertAnnotationValue(sema, value); - } - } - - static Object convertAnnotationValue(JSema sema, Object value) { - return switch (value) { - case IVariableBinding iVariableBinding -> sema.variableSymbol(iVariableBinding); - case ITypeBinding iTypeBinding -> sema.typeSymbol(iTypeBinding); - case IAnnotationBinding iAnnotationBinding -> sema.annotation(iAnnotationBinding); - case Object[] a -> { - Object[] result = new Object[a.length]; - for (int i = 0; i < a.length; i++) { - result[i] = convertAnnotationValue(sema, a[i]); - } - yield result; - } - case null, default -> value; - }; - } -} diff --git a/java-frontend/src/main/java/org/sonar/java/model/EcjTreeBindings.java b/java-frontend/src/main/java/org/sonar/java/model/EcjTreeBindings.java deleted file mode 100644 index 045d24b4eac..00000000000 --- a/java-frontend/src/main/java/org/sonar/java/model/EcjTreeBindings.java +++ /dev/null @@ -1,103 +0,0 @@ -/* - * SonarQube Java - * Copyright (C) SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * You can redistribute and/or modify this program under the terms of - * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.java.model; - -import java.util.function.Supplier; -import javax.annotation.Nullable; -import org.eclipse.jdt.core.dom.IBinding; -import org.eclipse.jdt.core.dom.IMethodBinding; -import org.eclipse.jdt.core.dom.ITypeBinding; -import org.eclipse.jdt.core.dom.IVariableBinding; -import org.sonar.java.model.declaration.ClassTreeImpl; -import org.sonar.java.model.declaration.MethodTreeImpl; -import org.sonar.java.model.declaration.VariableTreeImpl; -import org.sonar.java.model.expression.IdentifierTreeImpl; -import org.sonar.java.model.expression.LambdaExpressionTreeImpl; -import org.sonar.java.model.expression.MethodInvocationTreeImpl; -import org.sonar.java.model.pattern.AbstractPatternTree; - -final class EcjTreeBindings { - - private EcjTreeBindings() { - } - - @Nullable - static ITypeBinding typeBinding(Object tree) { - return switch (tree) { - case AbstractTypedTree t -> (ITypeBinding) EcjSemanticAttachment.getBinding(t.type); - case ClassTreeImpl t -> (ITypeBinding) EcjSemanticAttachment.getBinding(t.typeSymbol); - case TypeParameterTreeImpl t -> (ITypeBinding) EcjSemanticAttachment.getBinding(t.typeSymbol); - case AbstractPatternTree t -> (ITypeBinding) EcjSemanticAttachment.getBinding(t.type); - default -> throw new IllegalArgumentException("No ECJ type attachment: " + tree.getClass()); - }; - } - - @Nullable - static IMethodBinding methodBinding(Object tree) { - Supplier attachment = switch (tree) { - case MethodTreeImpl t -> t.methodSymbol; - case MethodInvocationTreeImpl t -> t.methodSymbolSupplier; - case LambdaExpressionTreeImpl t -> t.methodSymbol; - default -> throw new IllegalArgumentException("No ECJ method attachment: " + tree.getClass()); - }; - return (IMethodBinding) EcjSemanticAttachment.getBinding(attachment); - } - - @Nullable - static IVariableBinding variableBinding(VariableTreeImpl tree) { - return (IVariableBinding) EcjSemanticAttachment.getBinding(tree.variableSymbol); - } - - @Nullable - static IBinding binding(Object tree) { - return switch (tree) { - case IdentifierTreeImpl t -> EcjSemanticAttachment.getBinding(t.symbolSupplier); - case JavaTree.ImportTreeImpl t -> EcjSemanticAttachment.getBinding(t.symbolSupplier); - default -> throw new IllegalArgumentException("No ECJ symbol attachment: " + tree.getClass()); - }; - } - - static void setType(JSema sema, JavaTree tree, @Nullable ITypeBinding binding) { - switch (tree) { - case AbstractTypedTree t -> t.type = sema.typeSupplier(binding); - case ClassTreeImpl t -> t.typeSymbol = binding == null ? SemanticValues.UNKNOWN_TYPE_SYMBOL - : new EcjSemanticAttachment<>(binding, sema::typeSymbol); - case TypeParameterTreeImpl t -> t.typeSymbol = sema.symbolSupplier(binding); - default -> throw new IllegalArgumentException("No type attachment: " + tree.getClass()); - } - if (tree instanceof KeywordThis t) { - t.symbolSupplier = binding == null ? SemanticValues.UNKNOWN_SYMBOL - : new EcjSemanticAttachment<>(binding, b -> sema.typeSymbol(b).thisSymbol); - } else if (tree instanceof KeywordSuper t) { - t.symbolSupplier = binding == null ? SemanticValues.UNKNOWN_SYMBOL - : new EcjSemanticAttachment<>(binding, b -> sema.typeSymbol(b).superSymbol); - } - } - - static void setSymbol(JSema sema, JavaTree tree, @Nullable IBinding binding) { - switch (tree) { - case MethodTreeImpl t -> t.methodSymbol = sema.methodSupplier((IMethodBinding) binding); - case MethodInvocationTreeImpl t -> t.methodSymbolSupplier = sema.methodSupplier((IMethodBinding) binding); - case LambdaExpressionTreeImpl t -> t.methodSymbol = sema.methodSupplier((IMethodBinding) binding); - case VariableTreeImpl t -> t.variableSymbol = sema.symbolSupplier(binding); - case IdentifierTreeImpl t -> t.symbolSupplier = sema.symbolSupplier(binding); - case JavaTree.ImportTreeImpl t -> t.symbolSupplier = binding == null || binding.getKind() == IBinding.PACKAGE - || binding.getKind() == IBinding.MODULE ? () -> null : sema.symbolSupplier(binding); - default -> throw new IllegalArgumentException("No symbol attachment: " + tree.getClass()); - } - } -} diff --git a/java-frontend/src/main/java/org/sonar/java/model/JMethodSymbol.java b/java-frontend/src/main/java/org/sonar/java/model/JMethodSymbol.java index 4cdc7c88a87..0247451d7f6 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/JMethodSymbol.java +++ b/java-frontend/src/main/java/org/sonar/java/model/JMethodSymbol.java @@ -16,208 +16,181 @@ */ package org.sonar.java.model; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiAnnotationMethod; +import com.intellij.psi.PsiArrayType; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiClassType; +import com.intellij.psi.PsiLambdaExpression; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiModifier; +import com.intellij.psi.PsiSubstitutor; +import com.intellij.psi.PsiTypes; +import com.intellij.psi.util.MethodSignatureUtil; +import com.intellij.psi.util.TypeConversionUtil; import java.util.ArrayList; -import java.util.Collection; +import java.util.Arrays; +import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; -import java.util.function.Predicate; -import javax.annotation.Nullable; -import org.eclipse.jdt.core.dom.ASTUtils; -import org.eclipse.jdt.core.dom.IMethodBinding; -import org.eclipse.jdt.core.dom.ITypeBinding; -import org.eclipse.jdt.core.dom.Modifier; -import org.sonar.java.annotations.VisibleForTesting; +import java.util.stream.Collectors; import org.sonar.plugins.java.api.semantic.Symbol; import org.sonar.plugins.java.api.semantic.Type; import org.sonar.plugins.java.api.tree.MethodTree; -import org.sonar.plugins.java.api.tree.VariableTree; final class JMethodSymbol extends JSymbol implements Symbol.MethodSymbol { + final PsiMethod method; + final PsiSubstitutor substitutor; + private final PsiLambdaExpression lambda; - /** - * Cache for {@link #parameterTypes()}. - */ - private List parameterTypes; - - private List parameters; - - /** - * Cache for {@link #returnType()}. - */ - private TypeSymbol returnType; - - /** - * Cache for {@link #thrownTypes()}. - */ - private List thrownTypes; - - /** - * Cache for {@link #overriddenSymbols()}. - */ - private List overriddenSymbols; - - private final String signature; - - JMethodSymbol(JSema sema, IMethodBinding methodBinding) { - super(sema, methodBinding); - this.signature = methodBinding().getDeclaringClass().getBinaryName() - + "#" + name() - + ASTUtils.signature(methodBinding().getMethodDeclaration()); + JMethodSymbol(JSema sema, PsiMethod method, PsiSubstitutor substitutor, PsiLambdaExpression lambda, String key) { + super(sema, lambda == null ? method : lambda, key); + this.method = method; + this.substitutor = substitutor; + this.lambda = lambda; } - IMethodBinding methodBinding() { - return (IMethodBinding) binding; - } + boolean isLambda() { return lambda != null; } @Override - @Nullable - public Object defaultValue() { - return EcjSymbolMetadata.convertAnnotationValue(sema, methodBinding().getDefaultValue()); - } - - public boolean isLambda() { - return methodBinding().getDeclaringMember() != null; + public String name() { + return sema.read(() -> method.isConstructor() ? "" : method.getName()); } @Override - public List parameterTypes() { - if (parameterTypes == null) { - parameterTypes = sema.types(methodBinding().getParameterTypes()); - } - return parameterTypes; + public Symbol owner() { + return sema.read(() -> sema.type(JavaPsiFacade.getElementFactory(sema.project).createType(method.getContainingClass(), substitutor)).symbol()); } @Override - public List declarationParameters() { - if (parameters == null) { - MethodTree declaration = declaration(); - if (declaration != null && !isCompactConstructor(declaration)) { - parameters = declaration.parameters().stream().map(VariableTree::symbol).toList(); - } else { - parameters = new ArrayList<>(); - IMethodBinding methodBinding = methodBinding(); - ITypeBinding[] parameterTypeBindings = methodBinding.getParameterTypes(); - for (int i = 0; i < parameterTypeBindings.length; i++) { - parameters.add(new JVariableSymbol.ParameterPlaceholderSymbol(i, sema, methodBinding.getMethodDeclaration(), parameterTypeBindings[i])); - } - } - } - return parameters; + public TypeSymbol enclosingClass() { + return (TypeSymbol) owner(); } - private static boolean isCompactConstructor(MethodTree methodTree) { - return methodTree.closeParenToken() == null; + @Override + public List parameterTypes() { + return sema.read(() -> Arrays.stream(method.getParameterList().getParameters()).map(p -> sema.type(substitutor.substitute(p.getType()))).toList()); } - /** - * @since 6.0 returns void type for constructors instead of {@code null} - */ @Override - public TypeSymbol returnType() { - if (returnType == null) { - ITypeBinding methodBindingReturnType = methodBinding().getReturnType(); - // In rare circumstances, when the semantic information is incomplete, methodBindingReturnType can be null. - if (methodBindingReturnType == null) { - return TypeSymbol.UNKNOWN_TYPE; - } - this.returnType = sema.typeSymbol(methodBindingReturnType); - } - return returnType; + public Symbol.TypeSymbol returnType() { + return sema.read(() -> sema.type(method.isConstructor() ? PsiTypes.voidType() : substitutor.substitute(method.getReturnType())).symbol()); } @Override public List thrownTypes() { - if (thrownTypes == null) { - thrownTypes = sema.types(methodBinding().getExceptionTypes()); - } - return thrownTypes; + return sema.read(() -> Arrays.stream(method.getThrowsList().getReferencedTypes()).map(t -> sema.type(substitutor.substitute(t))).toList()); } @Override - public List overriddenSymbols() { - if (overriddenSymbols == null) { - overriddenSymbols = findOverriddenSymbols(); - } - return overriddenSymbols; + public MethodTree declaration() { + return lambda == null ? (MethodTree) super.declaration() : null; } - private List findOverriddenSymbols() { - Set results = new LinkedHashSet<>(); - IMethodBinding methodBinding = methodBinding(); - findOverridesInParentTypes(results, methodBinding::overrides, methodBinding.getDeclaringClass()); - return new ArrayList<>(results); + @Override + public boolean isParametrizedMethod() { + return sema.read(() -> method.hasTypeParameters()); } - @VisibleForTesting - void findOverridesInParentTypes(Collection accumulator, Predicate overridesCondition, ITypeBinding type) { - if (type.isInterface()) { - // check Object for interfaces forcing overrides from Object - findOverridesInTypes(accumulator, overridesCondition, sema.resolveType("java.lang.Object")); - } else if (!"java.lang.Object".equals(type.getQualifiedName())) { - findOverridesInTypes(accumulator, overridesCondition, type.getSuperclass()); - } - findOverridesInTypes(accumulator, overridesCondition, type.getInterfaces()); + @Override + public boolean isDefaultMethod() { + return modifier(PsiModifier.DEFAULT); } - private void findOverridesInTypes(Collection accumulator, Predicate overridesCondition, ITypeBinding... types) { - for (ITypeBinding type : types) { - if (type != null) { - for (IMethodBinding declaredMethod : type.getDeclaredMethods()) { - if (overridesCondition.test(declaredMethod)) { - accumulator.add(sema.methodSymbol(declaredMethod)); - break; - } - } - findOverridesInParentTypes(accumulator, overridesCondition, type); - } - } + @Override + public boolean isSynchronizedMethod() { + return modifier(PsiModifier.SYNCHRONIZED); } @Override - public String signature() { - return signature; + public boolean isNativeMethod() { + return modifier(PsiModifier.NATIVE); } @Override - public boolean isOverridable() { - return !isUnknown() && !(isPrivate() || isStatic() || isFinal() || owner().isFinal()); + public boolean isVarArgsMethod() { + return sema.read(method::isVarArgs); } @Override - public boolean isParametrizedMethod() { - return !isUnknown() && (methodBinding().isParameterizedMethod() || methodBinding().isGenericMethod()); + public boolean isOverridable() { + return !isPrivate() && !isStatic() && !isFinal() && !owner().isFinal(); } @Override - public boolean isDefaultMethod() { - return !isUnknown() && Modifier.isDefault(binding.getModifiers()); + public List declarationParameters() { + return sema.read(() -> Arrays.stream(lambda == null ? method.getParameterList().getParameters() : lambda.getParameterList().getParameters()) + .map(sema::symbol).toList()); } @Override - public boolean isSynchronizedMethod() { - return !isUnknown() && Modifier.isSynchronized(binding.getModifiers()); + public Object defaultValue() { + return sema.read(() -> method instanceof PsiAnnotationMethod annotation ? JSymbolMetadata.value(sema, annotation.getDefaultValue()) : null); } @Override - public boolean isVarArgsMethod() { - return !isUnknown() && methodBinding().isVarargs(); + public List overriddenSymbols() { + return sema.read(() -> { + Set result = new LinkedHashSet<>(); + if (!method.isConstructor() && !isStatic() && !isPrivate()) { + collectOverrides(method.getContainingClass(), PsiSubstitutor.EMPTY, result, new HashSet<>()); + } + return List.copyOf(result); + }); } - @Nullable - @Override - public MethodTree declaration() { - return (MethodTree) super.declaration(); + private void collectOverrides(PsiClass current, PsiSubstitutor substitution, Set result, Set seen) { + var parents = new ArrayList<>(Arrays.asList(current.getSuperTypes())); + if (current.isInterface()) { + var object = sema.resolveType("java.lang.Object"); + if (object instanceof PsiClassType objectType) { + parents.addFirst(objectType); + } + } + for (var type : parents) { + if (!(substitution.substitute(type) instanceof PsiClassType parentType)) { + continue; + } + var resolved = parentType.resolveGenerics(); + var cls = resolved.getElement(); + if (cls == null || !seen.add(sema.key(cls))) { + continue; + } + for (var parent : cls.findMethodsByName(method.getName(), false)) { + if (!parent.hasModifierProperty(PsiModifier.PRIVATE) && !parent.hasModifierProperty(PsiModifier.STATIC) + && MethodSignatureUtil.isSubsignature(parent.getSignature(resolved.getSubstitutor()), method.getSignature(PsiSubstitutor.EMPTY))) { + result.add(sema.method(parent, resolved.getSubstitutor())); + break; + } + } + collectOverrides(cls, resolved.getSubstitutor(), result, seen); + } } @Override - public boolean isNativeMethod() { - return !isUnknown() && Modifier.isNative(binding.getModifiers()); + public String signature() { + return sema.read(() -> sema.binaryName(method.getContainingClass()) + "#" + name() + "(" + + Arrays.stream(method.getParameterList().getParameters()).map(p -> descriptor(p.getType())).collect(Collectors.joining()) + + ")" + descriptor(method.isConstructor() ? PsiTypes.voidType() : method.getReturnType())); } - /** This is for debugging and doesn't follow a guaranteed format. */ - @Override - public String toString() { - return binding.getKey(); + private String descriptor(com.intellij.psi.PsiType type) { + var erased = TypeConversionUtil.erasure(type); + if (erased instanceof PsiArrayType array) { + return "[" + descriptor(array.getComponentType()); + } + return switch (erased.getCanonicalText(false)) { + case "void" -> "V"; + case "boolean" -> "Z"; + case "byte" -> "B"; + case "char" -> "C"; + case "short" -> "S"; + case "int" -> "I"; + case "long" -> "J"; + case "float" -> "F"; + case "double" -> "D"; + default -> "L" + sema.type(erased).fullyQualifiedName().replace('.', '/') + ";"; + }; } } diff --git a/java-frontend/src/main/java/org/sonar/java/model/JPackageSymbol.java b/java-frontend/src/main/java/org/sonar/java/model/JPackageSymbol.java index 1f7680c909e..13c6a692505 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/JPackageSymbol.java +++ b/java-frontend/src/main/java/org/sonar/java/model/JPackageSymbol.java @@ -16,12 +16,29 @@ */ package org.sonar.java.model; -import org.eclipse.jdt.core.dom.IPackageBinding; +import com.intellij.psi.PsiPackage; +import org.sonar.plugins.java.api.semantic.Symbol; final class JPackageSymbol extends JSymbol { + private final PsiPackage pkg; - JPackageSymbol(JSema sema, IPackageBinding binding) { - super(sema, binding); + JPackageSymbol(JSema sema, PsiPackage pkg, String key) { + super(sema, pkg, key); + this.pkg = pkg; } + @Override + public String name() { + return sema.read(pkg::getQualifiedName); + } + + @Override + public Symbol owner() { + return Symbol.ROOT_PACKAGE; + } + + @Override + public Symbol.TypeSymbol enclosingClass() { + return null; + } } diff --git a/java-frontend/src/main/java/org/sonar/java/model/JParser.java b/java-frontend/src/main/java/org/sonar/java/model/JParser.java index 4adbc9e5539..1db3736ce77 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/JParser.java +++ b/java-frontend/src/main/java/org/sonar/java/model/JParser.java @@ -16,150 +16,104 @@ */ package org.sonar.java.model; -import com.sonar.sslr.api.RecognitionException; +import com.intellij.openapi.project.Project; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiAnnotation; +import com.intellij.psi.PsiAnnotationMethod; +import com.intellij.psi.PsiAnonymousClass; +import com.intellij.psi.PsiArrayAccessExpression; +import com.intellij.psi.PsiArrayInitializerExpression; +import com.intellij.psi.PsiArrayInitializerMemberValue; +import com.intellij.psi.PsiAssertStatement; +import com.intellij.psi.PsiAssignmentExpression; +import com.intellij.psi.PsiBlockStatement; +import com.intellij.psi.PsiBreakStatement; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiClassInitializer; +import com.intellij.psi.PsiClassObjectAccessExpression; +import com.intellij.psi.PsiCodeBlock; +import com.intellij.psi.PsiConditionalExpression; +import com.intellij.psi.PsiContinueStatement; +import com.intellij.psi.PsiDeclarationStatement; +import com.intellij.psi.PsiDeconstructionPattern; +import com.intellij.psi.PsiDefaultCaseLabelElement; +import com.intellij.psi.PsiDoWhileStatement; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiEmptyStatement; +import com.intellij.psi.PsiEnumConstant; +import com.intellij.psi.PsiErrorElement; +import com.intellij.psi.PsiExpressionList; +import com.intellij.psi.PsiExpressionListStatement; +import com.intellij.psi.PsiExpressionStatement; +import com.intellij.psi.PsiField; +import com.intellij.psi.PsiFileFactory; +import com.intellij.psi.PsiForStatement; +import com.intellij.psi.PsiForeachStatement; +import com.intellij.psi.PsiIdentifier; +import com.intellij.psi.PsiIfStatement; +import com.intellij.psi.PsiImplicitClass; +import com.intellij.psi.PsiImportList; +import com.intellij.psi.PsiImportModuleStatement; +import com.intellij.psi.PsiImportStaticStatement; +import com.intellij.psi.PsiInstanceOfExpression; +import com.intellij.psi.PsiJavaCodeReferenceElement; +import com.intellij.psi.PsiJavaFile; +import com.intellij.psi.PsiJavaModule; +import com.intellij.psi.PsiJavaToken; +import com.intellij.psi.PsiKeyword; +import com.intellij.psi.PsiLabeledStatement; +import com.intellij.psi.PsiLambdaExpression; +import com.intellij.psi.PsiLiteralExpression; +import com.intellij.psi.PsiLocalVariable; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiMethodCallExpression; +import com.intellij.psi.PsiMethodReferenceExpression; +import com.intellij.psi.PsiModifierList; +import com.intellij.psi.PsiNewExpression; +import com.intellij.psi.PsiPackageAccessibilityStatement; +import com.intellij.psi.PsiParameter; +import com.intellij.psi.PsiParenthesizedExpression; +import com.intellij.psi.PsiPattern; +import com.intellij.psi.PsiPolyadicExpression; +import com.intellij.psi.PsiPostfixExpression; +import com.intellij.psi.PsiPrefixExpression; +import com.intellij.psi.PsiProvidesStatement; +import com.intellij.psi.PsiQualifiedExpression; +import com.intellij.psi.PsiReferenceExpression; +import com.intellij.psi.PsiReferenceList; +import com.intellij.psi.PsiReferenceParameterList; +import com.intellij.psi.PsiRequiresStatement; +import com.intellij.psi.PsiResourceExpression; +import com.intellij.psi.PsiResourceVariable; +import com.intellij.psi.PsiReturnStatement; +import com.intellij.psi.PsiStatement; +import com.intellij.psi.PsiSuperExpression; +import com.intellij.psi.PsiSwitchBlock; +import com.intellij.psi.PsiSwitchExpression; +import com.intellij.psi.PsiSwitchLabelStatementBase; +import com.intellij.psi.PsiSwitchLabeledRuleStatement; +import com.intellij.psi.PsiSwitchStatement; +import com.intellij.psi.PsiSynchronizedStatement; +import com.intellij.psi.PsiThisExpression; +import com.intellij.psi.PsiThrowStatement; +import com.intellij.psi.PsiTryStatement; +import com.intellij.psi.PsiTypeCastExpression; +import com.intellij.psi.PsiTypeElement; +import com.intellij.psi.PsiTypeParameterList; +import com.intellij.psi.PsiTypeTestPattern; +import com.intellij.psi.PsiUnnamedPattern; +import com.intellij.psi.PsiUsesStatement; +import com.intellij.psi.PsiVariable; +import com.intellij.psi.PsiWhileStatement; +import com.intellij.psi.PsiYieldStatement; +import com.intellij.psi.util.PsiTreeUtil; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; -import java.util.Deque; -import java.util.HashMap; -import java.util.Iterator; -import java.util.LinkedList; +import java.util.IdentityHashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import java.util.Objects; -import java.util.Optional; -import java.util.Set; -import java.util.function.Function; -import java.util.function.Predicate; -import java.util.stream.Collectors; -import java.util.stream.IntStream; -import java.util.stream.Stream; -import javax.annotation.Nullable; -import org.eclipse.jdt.core.compiler.IProblem; -import org.eclipse.jdt.core.compiler.InvalidInputException; -import org.eclipse.jdt.core.dom.AST; -import org.eclipse.jdt.core.dom.ASTNode; -import org.eclipse.jdt.core.dom.ASTParser; -import org.eclipse.jdt.core.dom.ASTUtils; -import org.eclipse.jdt.core.dom.AbstractTypeDeclaration; -import org.eclipse.jdt.core.dom.Annotation; -import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration; -import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration; -import org.eclipse.jdt.core.dom.AnonymousClassDeclaration; -import org.eclipse.jdt.core.dom.ArrayAccess; -import org.eclipse.jdt.core.dom.ArrayCreation; -import org.eclipse.jdt.core.dom.ArrayInitializer; -import org.eclipse.jdt.core.dom.ArrayType; -import org.eclipse.jdt.core.dom.AssertStatement; -import org.eclipse.jdt.core.dom.Assignment; -import org.eclipse.jdt.core.dom.Block; -import org.eclipse.jdt.core.dom.BodyDeclaration; -import org.eclipse.jdt.core.dom.BooleanLiteral; -import org.eclipse.jdt.core.dom.BreakStatement; -import org.eclipse.jdt.core.dom.CastExpression; -import org.eclipse.jdt.core.dom.CatchClause; -import org.eclipse.jdt.core.dom.CharacterLiteral; -import org.eclipse.jdt.core.dom.ClassInstanceCreation; -import org.eclipse.jdt.core.dom.CompilationUnit; -import org.eclipse.jdt.core.dom.ConditionalExpression; -import org.eclipse.jdt.core.dom.ConstructorInvocation; -import org.eclipse.jdt.core.dom.ContinueStatement; -import org.eclipse.jdt.core.dom.CreationReference; -import org.eclipse.jdt.core.dom.Dimension; -import org.eclipse.jdt.core.dom.DoStatement; -import org.eclipse.jdt.core.dom.EmptyStatement; -import org.eclipse.jdt.core.dom.EnhancedForStatement; -import org.eclipse.jdt.core.dom.EnumConstantDeclaration; -import org.eclipse.jdt.core.dom.EnumDeclaration; -import org.eclipse.jdt.core.dom.ExportsDirective; -import org.eclipse.jdt.core.dom.Expression; -import org.eclipse.jdt.core.dom.ExpressionMethodReference; -import org.eclipse.jdt.core.dom.ExpressionStatement; -import org.eclipse.jdt.core.dom.FieldAccess; -import org.eclipse.jdt.core.dom.FieldDeclaration; -import org.eclipse.jdt.core.dom.ForStatement; -import org.eclipse.jdt.core.dom.GuardedPattern; -import org.eclipse.jdt.core.dom.IBinding; -import org.eclipse.jdt.core.dom.IExtendedModifier; -import org.eclipse.jdt.core.dom.IMethodBinding; -import org.eclipse.jdt.core.dom.ITypeBinding; -import org.eclipse.jdt.core.dom.IVariableBinding; -import org.eclipse.jdt.core.dom.IfStatement; -import org.eclipse.jdt.core.dom.ImportDeclaration; -import org.eclipse.jdt.core.dom.InfixExpression; -import org.eclipse.jdt.core.dom.Initializer; -import org.eclipse.jdt.core.dom.InstanceofExpression; -import org.eclipse.jdt.core.dom.IntersectionType; -import org.eclipse.jdt.core.dom.LabeledStatement; -import org.eclipse.jdt.core.dom.LambdaExpression; -import org.eclipse.jdt.core.dom.MemberValuePair; -import org.eclipse.jdt.core.dom.MethodDeclaration; -import org.eclipse.jdt.core.dom.MethodInvocation; -import org.eclipse.jdt.core.dom.ModuleDeclaration; -import org.eclipse.jdt.core.dom.ModuleDirective; -import org.eclipse.jdt.core.dom.ModuleModifier; -import org.eclipse.jdt.core.dom.Name; -import org.eclipse.jdt.core.dom.NameQualifiedType; -import org.eclipse.jdt.core.dom.NormalAnnotation; -import org.eclipse.jdt.core.dom.NullLiteral; -import org.eclipse.jdt.core.dom.NumberLiteral; -import org.eclipse.jdt.core.dom.OpensDirective; -import org.eclipse.jdt.core.dom.ParameterizedType; -import org.eclipse.jdt.core.dom.ParenthesizedExpression; -import org.eclipse.jdt.core.dom.Pattern; -import org.eclipse.jdt.core.dom.PatternInstanceofExpression; -import org.eclipse.jdt.core.dom.PostfixExpression; -import org.eclipse.jdt.core.dom.PrefixExpression; -import org.eclipse.jdt.core.dom.PrimitiveType; -import org.eclipse.jdt.core.dom.ProvidesDirective; -import org.eclipse.jdt.core.dom.QualifiedName; -import org.eclipse.jdt.core.dom.QualifiedType; -import org.eclipse.jdt.core.dom.RecordDeclaration; -import org.eclipse.jdt.core.dom.RecordPattern; -import org.eclipse.jdt.core.dom.RequiresDirective; -import org.eclipse.jdt.core.dom.ReturnStatement; -import org.eclipse.jdt.core.dom.SimpleName; -import org.eclipse.jdt.core.dom.SimpleType; -import org.eclipse.jdt.core.dom.SingleMemberAnnotation; -import org.eclipse.jdt.core.dom.SingleVariableDeclaration; -import org.eclipse.jdt.core.dom.Statement; -import org.eclipse.jdt.core.dom.StringLiteral; -import org.eclipse.jdt.core.dom.SuperConstructorInvocation; -import org.eclipse.jdt.core.dom.SuperFieldAccess; -import org.eclipse.jdt.core.dom.SuperMethodInvocation; -import org.eclipse.jdt.core.dom.SuperMethodReference; -import org.eclipse.jdt.core.dom.SwitchCase; -import org.eclipse.jdt.core.dom.SwitchExpression; -import org.eclipse.jdt.core.dom.SwitchStatement; -import org.eclipse.jdt.core.dom.SynchronizedStatement; -import org.eclipse.jdt.core.dom.TextBlock; -import org.eclipse.jdt.core.dom.ThisExpression; -import org.eclipse.jdt.core.dom.ThrowStatement; -import org.eclipse.jdt.core.dom.TryStatement; -import org.eclipse.jdt.core.dom.Type; -import org.eclipse.jdt.core.dom.TypeDeclaration; -import org.eclipse.jdt.core.dom.TypeDeclarationStatement; -import org.eclipse.jdt.core.dom.TypeLiteral; -import org.eclipse.jdt.core.dom.TypeMethodReference; -import org.eclipse.jdt.core.dom.TypeParameter; -import org.eclipse.jdt.core.dom.TypePattern; -import org.eclipse.jdt.core.dom.UnionType; -import org.eclipse.jdt.core.dom.UsesDirective; -import org.eclipse.jdt.core.dom.VariableDeclaration; -import org.eclipse.jdt.core.dom.VariableDeclarationExpression; -import org.eclipse.jdt.core.dom.VariableDeclarationFragment; -import org.eclipse.jdt.core.dom.VariableDeclarationStatement; -import org.eclipse.jdt.core.dom.WhileStatement; -import org.eclipse.jdt.core.dom.WildcardType; -import org.eclipse.jdt.core.dom.YieldStatement; -import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; -import org.eclipse.jdt.internal.compiler.parser.Scanner; -import org.eclipse.jdt.internal.compiler.parser.TerminalToken; -import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions; -import org.eclipse.jdt.internal.formatter.Token; -import org.eclipse.jdt.internal.formatter.TokenManager; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.sonar.java.annotations.VisibleForTesting; import org.sonar.java.ast.parser.ArgumentListTreeImpl; import org.sonar.java.ast.parser.FormalParametersListTreeImpl; import org.sonar.java.ast.parser.InitializerListTreeImpl; @@ -229,15 +183,14 @@ import org.sonar.java.model.statement.TryStatementTreeImpl; import org.sonar.java.model.statement.WhileStatementTreeImpl; import org.sonar.java.model.statement.YieldStatementTreeImpl; +import org.sonar.java.psi.JavaPsiConfiguration; +import org.sonar.java.psi.JavaPsiEnvironment; import org.sonar.plugins.java.api.tree.AnnotationTree; import org.sonar.plugins.java.api.tree.ArrayDimensionTree; -import org.sonar.plugins.java.api.tree.ArrayTypeTree; import org.sonar.plugins.java.api.tree.CatchTree; import org.sonar.plugins.java.api.tree.ExpressionTree; -import org.sonar.plugins.java.api.tree.IdentifierTree; import org.sonar.plugins.java.api.tree.ImportClauseTree; import org.sonar.plugins.java.api.tree.InferedTypeTree; -import org.sonar.plugins.java.api.tree.ListTree; import org.sonar.plugins.java.api.tree.Modifier; import org.sonar.plugins.java.api.tree.ModifierTree; import org.sonar.plugins.java.api.tree.ModuleDeclarationTree; @@ -246,2695 +199,1213 @@ import org.sonar.plugins.java.api.tree.PatternTree; import org.sonar.plugins.java.api.tree.StatementTree; import org.sonar.plugins.java.api.tree.SyntaxToken; -import org.sonar.plugins.java.api.tree.SyntaxTrivia; -import org.sonar.plugins.java.api.tree.SyntaxTrivia.CommentKind; import org.sonar.plugins.java.api.tree.Tree; -import org.sonar.plugins.java.api.tree.TypeParameterTree; import org.sonar.plugins.java.api.tree.TypeTree; import org.sonar.plugins.java.api.tree.VariableTree; -import static org.sonar.java.model.EcjTreeBindings.binding; -import static org.sonar.java.model.EcjTreeBindings.methodBinding; -import static org.sonar.java.model.EcjTreeBindings.typeBinding; -import static org.sonar.java.model.EcjTreeBindings.variableBinding; - -@SuppressWarnings({"rawtypes", "unchecked"}) -public class JParser { - - private void setType(JavaTree tree, @Nullable ITypeBinding binding) { - EcjTreeBindings.setType(sema, tree, binding); - } - - private void setSymbol(JavaTree tree, @Nullable IBinding binding) { - EcjTreeBindings.setSymbol(sema, tree, binding); - } - - private KeywordThis keywordThis(InternalSyntaxToken token, @Nullable ITypeBinding binding) { - KeywordThis tree = new KeywordThis(token); - setType(tree, binding); +/** Builds the existing Sonar syntax and lazy semantic model from PSI. */ +public final class JParser { + /** Converts a file in an owned PSI environment and attaches lazy semantics and diagnostics. */ + static JavaTree.CompilationUnitTreeImpl convert(JavaPsiEnvironment environment, Project project, PsiJavaFile file, + JavaPsiConfiguration configuration, String source, Runnable cleaner) { + var diagnostics = PsiDiagnosticProvider.create(file, configuration, source); + var converter = new JParser(file, source); + var tree = converter.convert(); + var sema = new JSema(environment, project, file, cleaner, !configuration.runtimeArchives().isEmpty()); + PsiSemanticAttachment.attach(sema, tree, converter.semanticNodeMap(tree)); + diagnostics.attach(tree); return tree; } - private KeywordSuper keywordSuper(InternalSyntaxToken token, @Nullable ITypeBinding binding) { - KeywordSuper tree = new KeywordSuper(token); - setType(tree, binding); - return tree; - } - - private static final Logger LOG = LoggerFactory.getLogger(JParser.class); - - private static final Set WRONGLY_CATEGORIZED_AS_SYNTAX_ERROR = Set.of( - // Accept missing default clause, it may be due to missing semantic information of the switch expression, - // in this case, an enum fully covered with the switch cases will be seen as something that is not an enum - // when it is unknown, and the parser will wrongly consider the missing default clause as a syntax error. - IProblem.SwitchExpressionsYieldMissingDefaultCase, - // Accept missing default clause, it may be due the switch expression being an enum from a wrong dependency. - // In this case, the parser will wrongly consider the missing default clause as a syntax error. - IProblem.SwitchExpressionsYieldMissingEnumConstantCase - ); - - private static final Predicate IS_SYNTAX_ERROR = error -> ((error.getID() & IProblem.Syntax) != 0) && - !WRONGLY_CATEGORIZED_AS_SYNTAX_ERROR.contains(error.getID()); + private final PsiJavaFile file; + private final PsiTokenIndex tokens; + private final String source; + private final PsiTokenIndex.UnicodeInput input; + private final LineColumnConverter positions; + private final Map> nodes = new IdentityHashMap<>(); + private final Map annotations = new LinkedHashMap<>(); - private static final Predicate IS_UNDEFINED_TYPE_ERROR = error -> (error.getID() & IProblem.UndefinedType) != 0; - - /** - * @param unitName see {@link ASTParser#setUnitName(String)} - * @throws RecognitionException in case of syntax errors - */ - public static JavaTree.CompilationUnitTreeImpl parse(ASTParser astParser, String version, String unitName, String source) { - return parse(astParser, version, unitName, source, ast -> null); + JParser(PsiJavaFile file) { + this(file, file.getText()); } - static JavaTree.CompilationUnitTreeImpl parse(ASTParser astParser, String version, String unitName, String source, Function environmentOwner) { - astParser.setUnitName(unitName); - astParser.setSource(source.toCharArray()); - - CompilationUnit astNode; - try { - astNode = (CompilationUnit) astParser.createAST(null); - } catch (Exception e) { - LOG.error("ECJ: Unable to parse file", e); - throw new RecognitionException(-1, "ECJ: Unable to parse file.", e); + JParser(PsiJavaFile file, String source) { + this.source = source; + input = PsiTokenIndex.unicodeInput(source); + positions = new LineColumnConverter(source); + this.file = input.text().equals(file.getText()) ? file + : (PsiJavaFile) PsiFileFactory.getInstance(file.getProject()).createFileFromText(file.getName(), file.getFileType(), input.text()); + tokens = new PsiTokenIndex(source); + for (var annotation : PsiTreeUtil.findChildrenOfType(this.file, PsiAnnotation.class)) { + annotations.put(start(annotation), annotation); } + } - return convert(version, unitName, source, astNode, environmentOwner.apply(astNode)); + Map> nodeMap() { + Map> result = new IdentityHashMap<>(); + nodes.forEach((element, trees) -> result.put(element, List.copyOf(trees))); + return Collections.unmodifiableMap(result); } - static JavaTree.CompilationUnitTreeImpl convert(String version, String unitName, String source, CompilationUnit astNode) { - return convert(version, unitName, source, astNode, null); + /** Completes semantic origins for syntax fragments assembled from the token cursor. */ + Map> semanticNodeMap(JavaTree root) { + Map known = new IdentityHashMap<>(); + nodes.values().forEach(trees -> trees.forEach(tree -> known.put(tree, true))); + semanticOrigins(root, known); + return nodeMap(); } - static JavaTree.CompilationUnitTreeImpl convert(String version, String unitName, String source, CompilationUnit astNode, - @Nullable Runnable environmentCleaner) { - List errors = Stream.of(astNode.getProblems()).filter(IProblem::isError).toList(); - Optional possibleSyntaxError = errors.stream().filter(IS_SYNTAX_ERROR).findFirst(); - LineColumnConverter lineColumnConverter = new LineColumnConverter(source); - if (possibleSyntaxError.isPresent()) { - IProblem syntaxError = possibleSyntaxError.get(); - LineColumnConverter.Pos pos = lineColumnConverter.toPos(syntaxError.getSourceStart()); - String message = String.format("Parse error at line %d column %d: %s", pos.line(), pos.columnOffset() + 1, syntaxError.getMessage()); - // interrupt parsing - throw new RecognitionException(pos.line(), message); + private void semanticOrigins(JavaTree tree, Map known) { + if (!known.containsKey(tree) && tree instanceof AbstractTypedTree && tree.firstToken() != null) { + int physical = offset(tree.firstToken()); + int translated = Arrays.binarySearch(input.offsets(), physical); + if (translated < 0) { + translated = -translated - 1; + } + var element = file.findElementAt(translated); + while (element != null && !(element instanceof com.intellij.psi.PsiExpression) && !(element instanceof PsiJavaCodeReferenceElement) + && !(element instanceof PsiTypeElement) && !(element instanceof PsiVariable) && !(element instanceof PsiClass)) { + element = element.getParent(); + } + if (element != null) { + remember(element, tree); + } + } + if (!tree.is(Tree.Kind.TOKEN, Tree.Kind.INFERED_TYPE)) { + tree.getChildren().forEach(child -> semanticOrigins((JavaTree) child, known)); } - - Set undefinedTypes = errors.stream() - .filter(IS_UNDEFINED_TYPE_ERROR) - .map(i -> new JProblem( - i.getMessage(), - (i.getID() & IProblem.PreviewFeatureUsed) == 0 ? JProblem.Type.UNDEFINED_TYPE : JProblem.Type.PREVIEW_FEATURE_USED)) - .collect(Collectors.toSet()); - - JParser converter = new JParser(); - converter.sema = new JSema(astNode.getAST(), environmentCleaner); - converter.compilationUnit = astNode; - converter.tokenManager = createTokenManager(version, unitName, source); - converter.lineColumnConverter = lineColumnConverter; - - JavaTree.CompilationUnitTreeImpl tree = converter.convertCompilationUnit(astNode); - tree.sema = converter.sema; - tree.undefinedTypes.addAll(undefinedTypes); - JWarning.Mapper.warningsFor(EcjDiagnosticProvider.warnings(astNode, converter.lineColumnConverter)).mappedInto(tree); - - ASTUtils.mayTolerateMissingType(astNode.getAST()); - - setParents(tree); - return tree; } - @VisibleForTesting - static TokenManager createTokenManager(String version, String unitName, String source) { - return new TokenManager(lex(version, unitName, source.toCharArray()), source, new DefaultCodeFormatterOptions(new HashMap<>())); - } - - private static void setParents(Tree node) { - Iterator childrenIterator = iteratorFor(node); - while (childrenIterator.hasNext()) { - Tree child = childrenIterator.next(); - ((JavaTree) child).setParent(node); - setParents(child); - } - } - - private static Iterator iteratorFor(Tree node) { - if (node.kind() == Tree.Kind.INFERED_TYPE || node.kind() == Tree.Kind.TOKEN) { - // getChildren throws exception in this case - return Collections.emptyIterator(); - } - return ((JavaTree) node).getChildren().iterator(); - } - - @VisibleForTesting - static List lex(String version, String unitName, char[] sourceChars) { - List tokens = new ArrayList<>(); - Scanner scanner = new Scanner( - true, - false, - false, - CompilerOptions.versionToJdkLevel(version), - null, - null, - false - ); - scanner.fakeInModule = "module-info.java".equals(unitName); - scanner.setSource(sourceChars); - while (true) { - try { - TerminalToken tokenType = scanner.getNextToken(); - Token token = Token.fromCurrent(scanner, tokenType); - tokens.add(token); - if (tokenType == TerminalToken.TokenNameEOF) { - break; + JavaTree.CompilationUnitTreeImpl convert() { + PackageDeclarationTree packageTree = null; + var declaration = file.getPackageStatement(); + if (declaration != null) { + packageTree = remember(declaration, new JavaTree.PackageDeclarationTreeImpl( + annotationList(declaration.getAnnotationList()), token(declaration, "package"), + name(declaration.getPackageReference()), token(declaration, ";"))); + } + List imports = new ArrayList<>(); + List types = new ArrayList<>(); + ModuleDeclarationTree module = null; + for (var child : file.getChildren()) { + if (child instanceof PsiImportList list) { + for (var entry : list.getAllImportStatements()) { + var reference = entry.getImportReference(); + boolean moduleImport = entry instanceof PsiImportModuleStatement; + ExpressionTree imported = moduleImport ? dottedName(((PsiImportModuleStatement) entry).getModuleReference()) : name(reference); + if (entry.isOnDemand() && !moduleImport) { + imported = new MemberSelectExpressionTreeImpl(imported, last(entry, "."), new IdentifierTreeImpl(last(entry, "*"))); + } + imports.add(remember(entry, new JavaTree.ImportTreeImpl(token(entry, "import"), + entry instanceof PsiImportStaticStatement ? token(entry, "static") : null, + moduleImport ? token(entry, "module") : null, imported, last(entry, ";")))); + appendSemicolons(end(entry), end(list), imports); } - } catch (InvalidInputException e) { - throw new IllegalStateException(e); + } else if (child instanceof PsiClass cls) { + types.add(classTree(cls)); + appendSemicolons(end(cls), end(file), types); + } else if (child instanceof PsiJavaModule javaModule) { + module = module(javaModule); + } else if (child instanceof PsiErrorElement) { + throw unsupported(child); } } - return tokens; - } - - private CompilationUnit compilationUnit; - - private TokenManager tokenManager; - private LineColumnConverter lineColumnConverter; - - private JSema sema; - - private final Deque labels = new LinkedList<>(); - - private void declaration(@Nullable IBinding binding, Tree node) { - if (binding == null) { - return; + if (file.getImportList() == null || file.getImportList().getAllImportStatements().length == 0) { + if (types.isEmpty()) { + appendSemicolons(0, end(file), imports); + } } - sema.declarations.put(binding, node); + var result = remember(file, new JavaTree.CompilationUnitTreeImpl(packageTree, imports, types, module, tokens.eof())); + parents(result); + return result; } - private void usage(@Nullable IBinding binding, IdentifierTree node) { - if (binding == null) { + private static void parents(JavaTree tree) { + if (tree.is(Tree.Kind.TOKEN, Tree.Kind.INFERED_TYPE)) { return; } - binding = JSema.declarationBinding(binding); - sema.usages.computeIfAbsent(binding, k -> new ArrayList<>()).add(node); - } - - private void usageLabel(@Nullable IdentifierTreeImpl node) { - if (node == null) { - return; + for (var child : tree.getChildren()) { + ((JavaTree) child).setParent(tree); + parents((JavaTree) child); } - labels.stream() - .filter(symbol -> symbol.name().equals(node.name())) - .findFirst() - .ifPresent(labelSymbol -> { - labelSymbol.usages.add(node); - node.labelSymbol = labelSymbol; - }); - } - - private int firstTokenIndexAfter(ASTNode e) { - int index = tokenManager.firstIndexAfter(e, ANY_TOKEN); - while (isComment(tokenManager.get(index))) { - index++; - } - return index; - } - - /** - * @param tokenType {@link TerminalToken} - */ - private int nextTokenIndex(int tokenIndex, TerminalToken tokenType) { - assert tokenType != ANY_TOKEN; - do { - tokenIndex += 1; - } while (tokenManager.get(tokenIndex).tokenType != tokenType); - return tokenIndex; - } - - /** - * @param tokenType {@link TerminalToken} - */ - private InternalSyntaxToken firstTokenBefore(ASTNode e, TerminalToken tokenType) { - return createSyntaxToken(tokenManager.firstIndexBefore(e, tokenType)); - } - - /** - * @param tokenType {@link TerminalToken} - */ - private InternalSyntaxToken firstTokenAfter(ASTNode e, TerminalToken tokenType) { - return createSyntaxToken(tokenManager.firstIndexAfter(e, tokenType)); - } - - /** - * @param tokenType {@link TerminalToken} - */ - private InternalSyntaxToken firstTokenIn(ASTNode e, TerminalToken tokenType) { - return createSyntaxToken(tokenManager.firstIndexIn(e, tokenType)); - } - - /** - * @param tokenTypeCandidateA {@link TerminalToken} - * @param tokenTypeCandidateB {@link TerminalToken} - * @return {@link TerminalToken} - */ - @VisibleForTesting - static int firstIndexIn(TokenManager tokenManager, ASTNode e, TerminalToken tokenTypeCandidateA, TerminalToken tokenTypeCandidateB) { - int first = tokenManager.firstIndexIn(e, ANY_TOKEN); - int last = tokenManager.lastIndexIn(e, ANY_TOKEN); - return IntStream.rangeClosed(first, last) - .filter(tokenIndex -> { - Token token = tokenManager.get(tokenIndex); - return token.tokenType == tokenTypeCandidateA || token.tokenType == tokenTypeCandidateB; - }) - .findFirst() - .orElseThrow(() -> new IllegalStateException("Failed to find token " + tokenTypeCandidateA + " or " + tokenTypeCandidateB + - " in the tokens of a " + ASTNode.nodeClassForType(e.getNodeType()).getName())); - } - - /** - * @param tokenType {@link TerminalToken} - */ - private InternalSyntaxToken lastTokenIn(ASTNode e, TerminalToken tokenType) { - return createSyntaxToken(tokenManager.lastIndexIn(e, tokenType)); - } - - private InternalSyntaxToken createSyntaxToken(int tokenIndex) { - Token t = tokenManager.get(tokenIndex); - String value; - boolean isEOF; - if (t.tokenType == TerminalToken.TokenNameEOF) { - isEOF = true; - value = ""; - } else { - isEOF = false; - value = t.toString(tokenManager.getSource()); - } - LineColumnConverter.Pos pos = lineColumnConverter.toPos(t.originalStart); - return new InternalSyntaxToken(pos.line(), pos.columnOffset(), value, collectComments(tokenIndex), isEOF); - } - - private InternalSyntaxToken createSpecialToken(int tokenIndex) { - Token t = tokenManager.get(tokenIndex); - List comments = t.tokenType == TerminalToken.TokenNameGREATER - ? collectComments(tokenIndex) - : Collections.emptyList(); - LineColumnConverter.Pos pos = lineColumnConverter.toPos(t.originalEnd); - return new InternalSyntaxToken(pos.line(), pos.columnOffset(), ">", comments, false); - } - - private List collectComments(int tokenIndex) { - int commentIndex = tokenIndex; - while (commentIndex > 0 && isComment(tokenManager.get(commentIndex - 1))) { - commentIndex--; - } - return IntStream.range(commentIndex, tokenIndex).mapToObj(i -> { - Token t = tokenManager.get(i); - LineColumnConverter.Pos pos = lineColumnConverter.toPos(t.originalStart); - return new InternalSyntaxTrivia(convertTokenTypeToCommentKind(t), - t.toString(tokenManager.getSource()), - pos.line(), - pos.columnOffset() - ); - }) - .toList(); - } - - @VisibleForTesting - static CommentKind convertTokenTypeToCommentKind(Token token) { - return switch (token.tokenType) { - case TokenNameCOMMENT_BLOCK -> CommentKind.BLOCK; - case TokenNameCOMMENT_JAVADOC -> CommentKind.JAVADOC; - case TokenNameCOMMENT_LINE -> CommentKind.LINE; - case TokenNameCOMMENT_MARKDOWN -> CommentKind.MARKDOWN; - default -> throw new IllegalStateException("Unexpected value: " + token.tokenType); - }; } - /** - * {@link Token#isComment()} has an issue https://github.com/eclipse-jdt/eclipse.jdt.core/issues/3914 - * it does not support Markdown comments. This method has to be used instead. - */ - @VisibleForTesting - static boolean isComment(Token token) { - return switch (token.tokenType) { - case TokenNameCOMMENT_BLOCK, TokenNameCOMMENT_JAVADOC, TokenNameCOMMENT_LINE, TokenNameCOMMENT_MARKDOWN -> true; - default -> false; - }; + private T remember(PsiElement source, T tree) { + nodes.computeIfAbsent(source, unused -> new ArrayList<>()).add(tree); + return tree; } - private void addEmptyStatementsToList(int tokenIndex, List list) { - while (true) { - Token token; - do { - tokenIndex++; - token = tokenManager.get(tokenIndex); - } while (isComment(token)); - - if (token.tokenType != TerminalToken.TokenNameSEMICOLON) { - break; - } - list.add(new EmptyStatementTreeImpl(createSyntaxToken(tokenIndex))); - } + private int start(PsiElement element) { + int offset = element.getTextRange().getStartOffset(); + return element.getContainingFile() == file ? input.offsets()[offset] : offset; } - private JavaTree.CompilationUnitTreeImpl convertCompilationUnit(CompilationUnit e) { - PackageDeclarationTree packageDeclaration = null; - if (e.getPackage() != null) { - packageDeclaration = new JavaTree.PackageDeclarationTreeImpl( - convertAnnotations(e.getPackage().annotations()), - firstTokenIn(e.getPackage(), TerminalToken.TokenNamepackage), - convertExpression(e.getPackage().getName()), - firstTokenIn(e.getPackage(), TerminalToken.TokenNameSEMICOLON) - ); - } - - List imports = new ArrayList<>(); - for (int i = 0; i < e.imports().size(); i++) { - ImportDeclaration e2 = (ImportDeclaration) e.imports().get(i); - ExpressionTree name = convertImportName(e2.getName()); - - boolean isModuleImport = org.eclipse.jdt.core.dom.Modifier.isModule(e2.getModifiers()); - - // "on demand" means `import pkg.*;` - if (e2.isOnDemand() && !isModuleImport) { - InternalSyntaxToken dotToken = lastTokenIn(e2, TerminalToken.TokenNameDOT); - InternalSyntaxToken identifierToken = lastTokenIn(e2, TerminalToken.TokenNameMULTIPLY); - name = new MemberSelectExpressionTreeImpl(name, dotToken, new IdentifierTreeImpl(identifierToken)); - } - - InternalSyntaxToken staticKeyword = e2.isStatic() ? firstTokenIn(e2, TerminalToken.TokenNamestatic) : null; - InternalSyntaxToken moduleKeyword = isModuleImport ? firstTokenIn(e2, TerminalToken.TokenNamemodule) : null; - - JavaTree.ImportTreeImpl t = new JavaTree.ImportTreeImpl( - firstTokenIn(e2, TerminalToken.TokenNameimport), - staticKeyword, - moduleKeyword, - name, - lastTokenIn(e2, TerminalToken.TokenNameSEMICOLON) - ); - - if (!isModuleImport) { - // There is no method to resolve bindings for a module import. - setSymbol(t, e2.resolveBinding()); - } - - imports.add(t); + private int end(PsiElement element) { + int offset = element.getTextRange().getEndOffset(); + return element.getContainingFile() == file ? input.offsets()[offset] : offset; + } - int tokenIndex = tokenManager.lastIndexIn(e2, TerminalToken.TokenNameSEMICOLON); - addEmptyStatementsToList(tokenIndex, imports); - } + private InternalSyntaxToken token(PsiElement element, String text) { + return tokens.find(start(element), end(element), text, false); + } - List types = new ArrayList<>(); - for (Object type : e.types()) { - processBodyDeclaration((AbstractTypeDeclaration) type, types); - } + private InternalSyntaxToken last(PsiElement element, String text) { + return tokens.find(start(element), end(element), text, true); + } - if (e.imports().isEmpty() && e.types().isEmpty()) { - addEmptyStatementsToList(-1, imports); + private InternalSyntaxToken exact(PsiElement element) { + if (element == null) { + throw new IllegalArgumentException("Missing source PSI element"); } + return tokens.slice(start(element), end(element)); + } - return new JavaTree.CompilationUnitTreeImpl( - packageDeclaration, - imports, - types, - convertModuleDeclaration(compilationUnit.getModule()), - firstTokenAfter(e, TerminalToken.TokenNameEOF) - ); + private IdentifierTreeImpl identifier(PsiElement element) { + return remember(element, new IdentifierTreeImpl(exact(element), element.getText().equals("_"))); } - private ExpressionTree convertImportName(Name node) { - switch (node.getNodeType()) { - case ASTNode.SIMPLE_NAME: { - return new IdentifierTreeImpl(firstTokenIn(node, TerminalToken.TokenNameIdentifier)); - } - case ASTNode.QUALIFIED_NAME: { - QualifiedName e = (QualifiedName) node; - return new MemberSelectExpressionTreeImpl( - convertImportName(e.getQualifier()), - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), - (IdentifierTreeImpl) convertImportName(e.getName())); - } - default: - throw new IllegalStateException(ASTNode.nodeClassForType(node.getNodeType()).toString()); + private ExpressionTree name(PsiJavaCodeReferenceElement reference) { + if (reference == null) { + throw new IllegalArgumentException("Missing Java reference"); } + ExpressionTree result = identifier(reference.getReferenceNameElement()); + if (reference.getQualifier() instanceof PsiJavaCodeReferenceElement qualifier) { + result = new MemberSelectExpressionTreeImpl(name(qualifier), + tokens.find(end(qualifier), start(reference.getReferenceNameElement()), ".", false), (IdentifierTreeImpl) result); + } + return remember(reference, result); } - @Nullable - private ModuleDeclarationTree convertModuleDeclaration(@Nullable ModuleDeclaration e) { - if (e == null) { - return null; - } - List moduleDirectives = e.moduleStatements().stream() - .map(o -> convertModuleDirective((ModuleDirective) o)) - .toList(); - return new ModuleDeclarationTreeImpl( - convertAnnotations(e.annotations()), - e.isOpen() ? firstTokenIn(e, TerminalToken.TokenNameopen) : null, - firstTokenBefore(e.getName(), TerminalToken.TokenNamemodule), - convertModuleName(e.getName()), - firstTokenAfter(e.getName(), TerminalToken.TokenNameLBRACE), - moduleDirectives, - lastTokenIn(e, TerminalToken.TokenNameRBRACE) - ); - } - - private ModuleNameTreeImpl convertModuleName(Name node) { - switch (node.getNodeType()) { - case ASTNode.QUALIFIED_NAME: { - QualifiedName e = (QualifiedName) node; - ModuleNameTreeImpl t = convertModuleName(e.getQualifier()); - t.add(new IdentifierTreeImpl(firstTokenIn(e.getName(), TerminalToken.TokenNameIdentifier))); - return t; - } - case ASTNode.SIMPLE_NAME: { - ModuleNameTreeImpl t = ModuleNameTreeImpl.emptyList(); - t.add(new IdentifierTreeImpl(firstTokenIn(node, TerminalToken.TokenNameIdentifier))); - return t; - } - default: - throw new IllegalStateException(ASTNode.nodeClassForType(node.getNodeType()).toString()); + private ExpressionTree dottedName(PsiElement element) { + var cursor = new TypeCursor(start(element), end(element)); + ExpressionTree result = new IdentifierTreeImpl(cursor.take()); + while (cursor.more()) { + var dot = cursor.take("."); + result = new MemberSelectExpressionTreeImpl(result, dot, new IdentifierTreeImpl(cursor.take())); } + return remember(element, result); } - private ModuleNameListTreeImpl convertModuleNames(List list) { - ModuleNameListTreeImpl t = ModuleNameListTreeImpl.emptyList(); - for (int i = 0; i < list.size(); i++) { - Name o = (Name) list.get(i); - if (i > 0) { - t.separators().add(firstTokenBefore(o, TerminalToken.TokenNameCOMMA)); + private void appendSemicolons(int offset, int limit, List list) { + for (var lexeme : tokens.lexemes().subList(tokens.index(offset), tokens.lexemes().size())) { + if (lexeme.start() >= limit || !lexeme.token().text().equals(";")) { + break; } - t.add(convertModuleName(o)); - } - return t; - } - - private ModuleDirectiveTree convertModuleDirective(ModuleDirective node) { - switch (node.getNodeType()) { - case ASTNode.REQUIRES_DIRECTIVE: { - RequiresDirective e = (RequiresDirective) node; - List modifiers = new ArrayList<>(); - for (Object o : e.modifiers()) { - switch (((ModuleModifier) o).getKeyword().toString()) { - case "static": - modifiers.add(new ModifierKeywordTreeImpl(Modifier.STATIC, firstTokenIn((ASTNode) o, ANY_TOKEN))); - break; - case "transitive": - modifiers.add(new ModifierKeywordTreeImpl(Modifier.TRANSITIVE, firstTokenIn((ASTNode) o, ANY_TOKEN))); - break; - default: - throw new IllegalStateException(); + list.add(new EmptyStatementTreeImpl(lexeme.token())); + } + } + + private ModuleDeclarationTree module(PsiJavaModule module) { + List directives = new ArrayList<>(); + for (var child : module.getChildren()) { + if (child instanceof PsiRequiresStatement requires) { + var reference = requires.getModuleReference(); + var moduleName = reference == null + ? singleModuleName(last(requires, "transitive")) : moduleName(reference.getElement()); + directives.add(new RequiresDirectiveTreeImpl(token(requires, "requires"), modifiers(requires.getModifierList()), + moduleName, last(requires, ";"))); + } else if (child instanceof PsiPackageAccessibilityStatement access) { + var names = ModuleNameListTreeImpl.emptyList(); + for (var reference : access.getModuleReferences()) { + if (!names.isEmpty()) { + names.separators().add(tokens.find(end(access.getPackageReference()), start(reference), ",", true)); } + names.add(moduleName(reference)); } - return new RequiresDirectiveTreeImpl( - firstTokenIn(e, TerminalToken.TokenNamerequires), - new ModifiersTreeImpl(modifiers), - convertModuleName(e.getName()), - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - case ASTNode.EXPORTS_DIRECTIVE: { - ExportsDirective e = (ExportsDirective) node; - return new ExportsDirectiveTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameexports), - convertExpression(e.getName()), - e.modules().isEmpty() ? null : firstTokenAfter(e.getName(), TerminalToken.TokenNameto), - convertModuleNames(e.modules()), - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - case ASTNode.OPENS_DIRECTIVE: { - OpensDirective e = (OpensDirective) node; - return new OpensDirectiveTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameopens), - convertExpression(e.getName()), - e.modules().isEmpty() ? null : firstTokenAfter(e.getName(), TerminalToken.TokenNameto), - convertModuleNames(e.modules()), - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - case ASTNode.USES_DIRECTIVE: { - UsesDirective e = (UsesDirective) node; - return new UsesDirectiveTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameuses), - (TypeTree) convertExpression(e.getName()), - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - case ASTNode.PROVIDES_DIRECTIVE: { - ProvidesDirective e = (ProvidesDirective) node; - QualifiedIdentifierListTreeImpl typeNames = QualifiedIdentifierListTreeImpl.emptyList(); - for (int i = 0; i < e.implementations().size(); i++) { - Name o = (Name) e.implementations().get(i); - if (i > 0) { - typeNames.separators().add(firstTokenBefore(o, TerminalToken.TokenNameCOMMA)); + var to = names.isEmpty() ? null : token(access, "to"); + if (access.getRole() == PsiPackageAccessibilityStatement.Role.EXPORTS) { + directives.add(new ExportsDirectiveTreeImpl(token(access, "exports"), name(access.getPackageReference()), to, names, last(access, ";"))); + } else { + directives.add(new OpensDirectiveTreeImpl(token(access, "opens"), name(access.getPackageReference()), to, names, last(access, ";"))); + } + } else if (child instanceof PsiUsesStatement uses) { + directives.add(new UsesDirectiveTreeImpl(token(uses, "uses"), (TypeTree) name(uses.getClassReference()), last(uses, ";"))); + } else if (child instanceof PsiProvidesStatement provides) { + var implementations = QualifiedIdentifierListTreeImpl.emptyList(); + var list = provides.getImplementationList(); + if (list != null) { + for (var reference : list.getReferenceElements()) { + if (!implementations.isEmpty()) { + implementations.separators().add(tokens.find(start(list), start(reference), ",", true)); + } + implementations.add((TypeTree) name(reference)); } - typeNames.add((TypeTree) convertExpression(o)); } - return new ProvidesDirectiveTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameprovides), - (TypeTree) convertExpression(e.getName()), - firstTokenAfter(e.getName(), TerminalToken.TokenNamewith), - typeNames, - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); + directives.add(new ProvidesDirectiveTreeImpl(token(provides, "provides"), (TypeTree) name(provides.getInterfaceReference()), + token(provides, "with"), implementations, last(provides, ";"))); } - default: - throw new IllegalStateException(ASTNode.nodeClassForType(node.getNodeType()).toString()); - } - } - - /** Converts implicitly declared unnamed class at the top level of a compact compilation unit. */ - private ClassTreeImpl convertUnnamedClassDeclaration(AbstractTypeDeclaration e) { - List members = new ArrayList<>(); - - for (Object o : e.bodyDeclarations()) { - processBodyDeclaration((BodyDeclaration) o, members); } - - ClassTreeImpl t = new ClassTreeImpl(Tree.Kind.IMPLICIT_CLASS, null, members, null); - - setType(t, e.resolveBinding()); - declaration(typeBinding(t), t); - - return t; + return remember(module, new ModuleDeclarationTreeImpl(annotationList(module.getModifierList()), + module.hasModifierProperty("open") ? token(module, "open") : null, + token(module, "module"), moduleName(module.getNameIdentifier()), token(module, "{"), directives, last(module, "}"))); } - private ClassTreeImpl convertTypeDeclaration(AbstractTypeDeclaration e) { - if (e.getNodeType() == ASTNode.UNNAMED_CLASS) { - return convertUnnamedClassDeclaration(e); - } - - List members = new ArrayList<>(); - - int leftBraceTokenIndex = findLeftBraceTokenIndex(e); - addEmptyStatementsToList(leftBraceTokenIndex, members); - - for (Object o : e.bodyDeclarations()) { - processBodyDeclaration((BodyDeclaration) o, members); - } - - ModifiersTreeImpl modifiers = convertModifiers(e.modifiers()); - IdentifierTreeImpl name = createSimpleName(e.getName()); - - InternalSyntaxToken openBraceToken = createSyntaxToken(leftBraceTokenIndex); - InternalSyntaxToken closeBraceToken = lastTokenIn(e, TerminalToken.TokenNameRBRACE); - - final ClassTreeImpl t; - switch (e.getNodeType()) { - case ASTNode.TYPE_DECLARATION: - t = convertTypeDeclaration((TypeDeclaration) e, modifiers, name, openBraceToken, members, closeBraceToken); - break; - case ASTNode.ENUM_DECLARATION: - t = convertEnumDeclaration((EnumDeclaration) e, modifiers, name, openBraceToken, members, closeBraceToken); - break; - case ASTNode.RECORD_DECLARATION: - t = convertRecordDeclaration((RecordDeclaration) e, modifiers, name, openBraceToken, members, closeBraceToken); - break; - case ASTNode.ANNOTATION_TYPE_DECLARATION: - t = convertAnnotationTypeDeclaration((AnnotationTypeDeclaration) e, modifiers, name, openBraceToken, members, closeBraceToken); - break; - default: - throw new IllegalStateException(ASTNode.nodeClassForType(e.getNodeType()).toString()); - } - - // no-op for annotation-types - completeSuperInterfaces(e, t); - - setType(t, e.resolveBinding()); - declaration(typeBinding(t), t); - - return t; + private ModuleNameTreeImpl singleModuleName(InternalSyntaxToken name) { + var moduleName = ModuleNameTreeImpl.emptyList(); + moduleName.add(new IdentifierTreeImpl(name)); + return moduleName; } - private ClassTreeImpl convertTypeDeclaration(TypeDeclaration e, ModifiersTreeImpl modifiers, IdentifierTreeImpl name, - InternalSyntaxToken openBraceToken, List members, InternalSyntaxToken closeBraceToken) { - InternalSyntaxToken declarationKeyword = firstTokenBefore(e.getName(), e.isInterface() ? TerminalToken.TokenNameinterface : TerminalToken.TokenNameclass); - ClassTreeImpl t = new ClassTreeImpl(e.isInterface() ? Tree.Kind.INTERFACE : Tree.Kind.CLASS, openBraceToken, members, closeBraceToken) - .complete(modifiers, declarationKeyword, name) - .completeTypeParameters(convertTypeParameters(e.typeParameters())); - - if (!e.permittedTypes().isEmpty()) { - List permittedTypes = e.permittedTypes(); - InternalSyntaxToken permitsKeyword = firstTokenBefore((Type) permittedTypes.get(0), TerminalToken.TokenNameRestrictedIdentifierpermits); - QualifiedIdentifierListTreeImpl classPermittedTypes = QualifiedIdentifierListTreeImpl.emptyList(); - - convertSeparatedTypeList(permittedTypes, classPermittedTypes); - t.completePermittedTypes(permitsKeyword, classPermittedTypes); - } - - if (!e.isInterface() && e.getSuperclassType() != null) { - Type superclassType = e.getSuperclassType(); - t.completeSuperclass(firstTokenBefore(superclassType, TerminalToken.TokenNameextends), convertType(superclassType)); + private ModuleNameTreeImpl moduleName(PsiElement reference) { + var result = ModuleNameTreeImpl.emptyList(); + var cursor = new TypeCursor(start(reference), end(reference)); + while (cursor.more()) { + result.add(new IdentifierTreeImpl(cursor.take())); + if (cursor.more()) { + cursor.take("."); + } } - return t; - } - - private ClassTreeImpl convertEnumDeclaration(EnumDeclaration e, ModifiersTreeImpl modifiers, IdentifierTreeImpl name, - InternalSyntaxToken openBraceToken, List members, InternalSyntaxToken closeBraceToken) { - List enumConstants = ((List) e.enumConstants()).stream() - .map(EnumConstantDeclaration.class::cast) - .map(this::processEnumConstantDeclaration) - .toList(); - members.addAll(0, enumConstants); - - InternalSyntaxToken declarationKeyword = firstTokenBefore(e.getName(), TerminalToken.TokenNameenum); - return new ClassTreeImpl(Tree.Kind.ENUM, openBraceToken, members, closeBraceToken) - .complete(modifiers, declarationKeyword, name); - } - - private ClassTreeImpl convertAnnotationTypeDeclaration(AnnotationTypeDeclaration e, ModifiersTreeImpl modifiers, IdentifierTreeImpl name, - InternalSyntaxToken openBraceToken, List members, InternalSyntaxToken closeBraceToken) { - InternalSyntaxToken declarationKeyword = firstTokenBefore(e.getName(), TerminalToken.TokenNameinterface); - return new ClassTreeImpl(Tree.Kind.ANNOTATION_TYPE, openBraceToken, members, closeBraceToken) - .complete(modifiers, declarationKeyword, name) - .completeAtToken(firstTokenBefore(e.getName(), TerminalToken.TokenNameAT)); - } - - private ClassTreeImpl convertRecordDeclaration(RecordDeclaration e, ModifiersTreeImpl modifiers, IdentifierTreeImpl name, - InternalSyntaxToken openBraceToken, List members, InternalSyntaxToken closeBraceToken) { - InternalSyntaxToken declarationKeyword = firstTokenBefore(e.getName(), TerminalToken.TokenNameRestrictedIdentifierrecord); - List recordComponents = e.recordComponents(); - InternalSyntaxToken openParen = firstTokenAfter(e.getName(), TerminalToken.TokenNameLPAREN); - InternalSyntaxToken closeParen = firstTokenAfter( - recordComponents.isEmpty() ? e.getName() : (ASTNode) recordComponents.get(recordComponents.size() - 1), - TerminalToken.TokenNameRPAREN); - return new ClassTreeImpl(Tree.Kind.RECORD, openBraceToken, members, closeBraceToken) - .complete(modifiers, declarationKeyword, name) - .completeTypeParameters(convertTypeParameters(e.typeParameters())) - .completeRecordComponents(openParen, convertRecordComponents(e), closeParen); + return result; } - private List convertRecordComponents(RecordDeclaration e) { - List recordComponents = new ArrayList<>(); - - for (int i = 0; i < e.recordComponents().size(); i++) { - SingleVariableDeclaration o = (SingleVariableDeclaration) e.recordComponents().get(i); - VariableTreeImpl recordComponent = convertVariable(o); - if (i < e.recordComponents().size() - 1) { - recordComponent.setEndToken(firstTokenAfter(o, TerminalToken.TokenNameCOMMA)); - } - recordComponents.add(recordComponent); + private List annotationList(PsiModifierList list) { + if (list == null) { + return List.of(); } - return recordComponents; + return Arrays.stream(list.getAnnotations()).map(a -> (AnnotationTree) annotation(a)).toList(); } - private int findLeftBraceTokenIndex(AbstractTypeDeclaration e) { - // TODO try to simplify, note that type annotations can contain LBRACE - if (e.getNodeType() == ASTNode.ENUM_DECLARATION) { - EnumDeclaration enumDeclaration = (EnumDeclaration) e; - if (!enumDeclaration.enumConstants().isEmpty()) { - return tokenManager.firstIndexBefore((ASTNode) enumDeclaration.enumConstants().get(0), TerminalToken.TokenNameLBRACE); - } - if (!enumDeclaration.bodyDeclarations().isEmpty()) { - return tokenManager.firstIndexBefore((ASTNode) e.bodyDeclarations().get(0), TerminalToken.TokenNameLBRACE); - } - return tokenManager.lastIndexIn(e, TerminalToken.TokenNameLBRACE); - } - if (!e.bodyDeclarations().isEmpty()) { - // for records, bodyDeclarations may not be in the order encountered in file, for classes they are - List bodyDeclarations = e.bodyDeclarations(); - BodyDeclaration firstDeclaration = bodyDeclarations.get(0); - for (int i = 1; i < bodyDeclarations.size(); i++) { - BodyDeclaration declaration = bodyDeclarations.get(i); - if (firstDeclaration.getStartPosition() > declaration.getStartPosition()) { - firstDeclaration = declaration; + private ModifiersTreeImpl modifiers(PsiModifierList list) { + List result = new ArrayList<>(); + if (list != null) { + for (var child : list.getChildren()) { + if (child instanceof PsiAnnotation annotation) { + result.add(annotation(annotation)); + } else if (child instanceof PsiKeyword) { + String keyword = PsiTokenIndex.decoded(child.getText()); + result.add(new ModifierKeywordTreeImpl(Modifier.valueOf(keyword.toUpperCase(java.util.Locale.ROOT).replace('-', '_')), exact(child))); } } - return tokenManager.firstIndexBefore(firstDeclaration, TerminalToken.TokenNameLBRACE); } - return tokenManager.lastIndexIn(e, TerminalToken.TokenNameLBRACE); + return new ModifiersTreeImpl(result); } - private void completeSuperInterfaces(AbstractTypeDeclaration e, ClassTreeImpl t) { - List superInterfaces = superInterfaceTypes(e); - if (!superInterfaces.isEmpty()) { - QualifiedIdentifierListTreeImpl interfaces = QualifiedIdentifierListTreeImpl.emptyList(); - convertSeparatedTypeList(superInterfaces, interfaces); - - ASTNode firstInterface = (ASTNode) superInterfaces.get(0); - InternalSyntaxToken keyword = firstTokenBefore(firstInterface, t.is(Tree.Kind.INTERFACE) ? TerminalToken.TokenNameextends : TerminalToken.TokenNameimplements); - t.completeInterfaces(keyword, interfaces); + private TypeTree type(PsiTypeElement element) { + if (element == null) { + return new InferedTypeTree(); } + return remember(element, new TypeCursor(start(element), end(element)).completeType()); } - private static List superInterfaceTypes(AbstractTypeDeclaration e) { - switch (e.getNodeType()) { - case ASTNode.TYPE_DECLARATION: - return ((TypeDeclaration) e).superInterfaceTypes(); - case ASTNode.ENUM_DECLARATION: - return ((EnumDeclaration) e).superInterfaceTypes(); - case ASTNode.RECORD_DECLARATION: - return ((RecordDeclaration) e).superInterfaceTypes(); - case ASTNode.ANNOTATION_TYPE_DECLARATION, ASTNode.UNNAMED_CLASS: - return Collections.emptyList(); - default: - throw new IllegalStateException(ASTNode.nodeClassForType(e.getNodeType()).toString()); - } - } - - private void convertSeparatedTypeList(List source, ListTree target) { - for (int i = 0; i < source.size(); i++) { - Type o = source.get(i); - T tree = (T) convertType(o); - if (i > 0) { - target.separators().add(firstTokenBefore(o, TerminalToken.TokenNameCOMMA)); - } - target.add(tree); - } - } + private final class TypeCursor { + private int offset; + private int consumedEnd; + private int physicalEnd; + private final int limit; + private boolean includeDimensions = true; - private EnumConstantTreeImpl processEnumConstantDeclaration(EnumConstantDeclaration e) { - final int openParTokenIndex = firstTokenIndexAfter(e.getName()); - final InternalSyntaxToken openParToken; - final InternalSyntaxToken closeParToken; - if (tokenManager.get(openParTokenIndex).tokenType == TerminalToken.TokenNameLPAREN) { - openParToken = createSyntaxToken(openParTokenIndex); - closeParToken = firstTokenAfter( - e.arguments().isEmpty() - ? e.getName() - : (ASTNode) e.arguments().get(e.arguments().size() - 1), - TerminalToken.TokenNameRPAREN); - } else { - openParToken = null; - closeParToken = null; + TypeCursor(int offset, int limit) { + this.offset = offset; + this.limit = limit; } - final ArgumentListTreeImpl arguments = convertArguments(openParToken, e.arguments(), closeParToken); - ClassTreeImpl classBody = null; - if (e.getAnonymousClassDeclaration() != null) { - List members = new ArrayList<>(); - for (Object o : e.getAnonymousClassDeclaration().bodyDeclarations()) { - processBodyDeclaration((BodyDeclaration) o, members); + private PsiTokenIndex.Lexeme current() { + var entries = tokens.lexemes(); + int i = tokens.index(offset); + if (i > 0 && entries.get(i - 1).end() > offset) { + return entries.get(i - 1); } - classBody = new ClassTreeImpl( - Tree.Kind.CLASS, - firstTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameLBRACE), - members, - lastTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameRBRACE) - ); - setType(classBody, e.getAnonymousClassDeclaration().resolveBinding()); - declaration(typeBinding(classBody), classBody); - } - - final int separatorTokenIndex = firstTokenIndexAfter(e); - final InternalSyntaxToken separatorToken; - switch (tokenManager.get(separatorTokenIndex).tokenType) { - case TokenNameCOMMA, - TokenNameSEMICOLON: - separatorToken = createSyntaxToken(separatorTokenIndex); - break; - case TokenNameRBRACE: - separatorToken = null; - break; - default: - throw new IllegalStateException(); + var result = entries.get(i); + offset = result.start(); + return result; } - IdentifierTreeImpl identifier = createSimpleName(e.getName()); - if (e.getAnonymousClassDeclaration() == null) { - setSymbol(identifier, excludeRecovery(e.resolveConstructorBinding(), arguments.size())); - } else { - setSymbol(identifier, findConstructorForAnonymousClass(e.getAST(), typeBinding(identifier), e.resolveConstructorBinding())); - } - usage(binding(identifier), identifier); - - EnumConstantTreeImpl t = new EnumConstantTreeImpl( - convertModifiers(e.modifiers()), - identifier, - new NewClassTreeImpl(identifier, arguments, classBody), - separatorToken - ); - setSymbol(t, e.resolveVariable()); - declaration(variableBinding(t), t); - return t; - } - - private void processBodyDeclaration(BodyDeclaration node, List members) { - final int lastTokenIndex; - - switch (node.getNodeType()) { - case ASTNode.ANNOTATION_TYPE_DECLARATION, - ASTNode.ENUM_DECLARATION, - ASTNode.RECORD_DECLARATION, - ASTNode.TYPE_DECLARATION, - ASTNode.UNNAMED_CLASS: - lastTokenIndex = processTypeDeclaration((AbstractTypeDeclaration) node, members); - break; - case ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION: - lastTokenIndex = processAnnotationTypeMemberDeclaration((AnnotationTypeMemberDeclaration) node, members); - break; - case ASTNode.INITIALIZER: - lastTokenIndex = processInitializerDeclaration((Initializer) node, members); - break; - case ASTNode.METHOD_DECLARATION: - lastTokenIndex = processMethodDeclaration((MethodDeclaration) node, members); - break; - case ASTNode.FIELD_DECLARATION: - lastTokenIndex = processFieldDeclaration((FieldDeclaration) node, members); - break; - default: - throw new IllegalStateException(ASTNode.nodeClassForType(node.getNodeType()).toString()); + boolean more() { + return current().start() < limit && offset < limit; } - addEmptyStatementsToList(lastTokenIndex, members); - } - - private int processTypeDeclaration(AbstractTypeDeclaration node, List members) { - members.add(convertTypeDeclaration(node)); - return tokenManager.lastIndexIn(node, TerminalToken.TokenNameRBRACE); - } - - private int processAnnotationTypeMemberDeclaration(AnnotationTypeMemberDeclaration e, List members) { - FormalParametersListTreeImpl parameters = new FormalParametersListTreeImpl( - firstTokenAfter(e.getName(), TerminalToken.TokenNameLPAREN), - firstTokenAfter(e.getName(), TerminalToken.TokenNameRPAREN)); - - Expression defaultExpression = e.getDefault(); - InternalSyntaxToken defaultToken = defaultExpression == null ? null : firstTokenBefore(defaultExpression, TerminalToken.TokenNamedefault); - ExpressionTree defaultValue = defaultExpression == null ? null : convertExpression(defaultExpression); - - MethodTreeImpl t = new MethodTreeImpl(parameters, defaultToken, defaultValue) - .complete(convertType(e.getType()), createSimpleName(e.getName()), lastTokenIn(e, TerminalToken.TokenNameSEMICOLON)) - .completeWithModifiers(convertModifiers(e.modifiers())); - - setSymbol(t, e.resolveBinding()); - declaration(methodBinding(t), t); - - members.add(t); - return tokenManager.lastIndexIn(e, TerminalToken.TokenNameSEMICOLON); - } - - private int processInitializerDeclaration(Initializer e, List members) { - BlockTreeImpl blockTree = convertBlock(e.getBody()); - if (org.eclipse.jdt.core.dom.Modifier.isStatic(e.getModifiers())) { - members.add(new StaticInitializerTreeImpl( - firstTokenIn(e, TerminalToken.TokenNamestatic), - (InternalSyntaxToken) blockTree.openBraceToken(), - blockTree.body(), - (InternalSyntaxToken) blockTree.closeBraceToken())); - } else { - members.add(new BlockTreeImpl( - Tree.Kind.INITIALIZER, - (InternalSyntaxToken) blockTree.openBraceToken(), - blockTree.body(), - (InternalSyntaxToken) blockTree.closeBraceToken())); + String peek() { + var entry = current(); + return PsiTokenIndex.decoded(source.substring(offset, entry.end())); } - return tokenManager.lastIndexIn(e, TerminalToken.TokenNameRBRACE); - } - private int processMethodDeclaration(MethodDeclaration e, List members) { - List p = e.parameters(); - final FormalParametersListTreeImpl formalParameters; - if (e.isCompactConstructor()) { - // only used for records - formalParameters = new FormalParametersListTreeImpl(null, null); - } else { - InternalSyntaxToken openParen = firstTokenAfter(e.getName(), TerminalToken.TokenNameLPAREN); - InternalSyntaxToken closeParen = firstTokenAfter(p.isEmpty() ? e.getName() : (ASTNode) p.get(p.size() - 1), TerminalToken.TokenNameRPAREN); - formalParameters = new FormalParametersListTreeImpl(openParen, closeParen); + InternalSyntaxToken take() { + var entry = current(); + var result = tokens.slice(offset, entry.end()); + offset = entry.end(); + consumedEnd = offset; + physicalEnd = offset; + return result; } - for (int i = 0; i < p.size(); i++) { - SingleVariableDeclaration o = (SingleVariableDeclaration) p.get(i); - VariableTreeImpl parameter = convertVariable(o); - if (i < p.size() - 1) { - parameter.setEndToken(firstTokenAfter(o, TerminalToken.TokenNameCOMMA)); + InternalSyntaxToken take(String expected) { + if (expected.equals(">") && peek().startsWith(">")) { + int end = offset + 1; + if (source.charAt(offset) == '\\') { + while (source.charAt(end) == 'u') { + end++; + } + end += 4; + } + var result = tokens.slice(offset, end); + offset = end; + consumedEnd = offset; + physicalEnd = offset; + return result; } - formalParameters.add(parameter); - } - - QualifiedIdentifierListTreeImpl thrownExceptionTypes = QualifiedIdentifierListTreeImpl.emptyList(); - List tt = e.thrownExceptionTypes(); - convertSeparatedTypeList(tt, thrownExceptionTypes); - - Block body = e.getBody(); - Type returnType = e.getReturnType2(); - InternalSyntaxToken throwsToken = tt.isEmpty() ? null : firstTokenBefore((Type) tt.get(0), TerminalToken.TokenNamethrows); - InternalSyntaxToken semcolonToken = body == null ? lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) : null; - MethodTreeImpl t = new MethodTreeImpl( - returnType == null ? null : applyExtraDimensions(convertType(returnType), e.extraDimensions()), - createSimpleName(e.getName()), - formalParameters, - throwsToken, - thrownExceptionTypes, - body == null ? null : convertBlock(body), - semcolonToken - ).completeWithModifiers( - convertModifiers(e.modifiers()) - ).completeWithTypeParameters( - convertTypeParameters(e.typeParameters()) - ); - setSymbol(t, e.resolveBinding()); - declaration(methodBinding(t), t); - - members.add(t); - return tokenManager.lastIndexIn(e, body == null ? TerminalToken.TokenNameSEMICOLON : TerminalToken.TokenNameRBRACE); - } - - private int processFieldDeclaration(FieldDeclaration fieldDeclaration, List members) { - ModifiersTreeImpl modifiers = convertModifiers(fieldDeclaration.modifiers()); - TypeTree type = convertType(fieldDeclaration.getType()); - - for (int i = 0; i < fieldDeclaration.fragments().size(); i++) { - VariableDeclarationFragment fragment = (VariableDeclarationFragment) fieldDeclaration.fragments().get(i); - VariableTreeImpl t = new VariableTreeImpl(createSimpleName(fragment.getName())) - .completeModifiersAndType(modifiers, applyExtraDimensions(type, fragment.extraDimensions())); - - if (fragment.getInitializer() != null) { - t.completeTypeAndInitializer(t.type(), firstTokenAfter(fragment.getName(), TerminalToken.TokenNameEQUAL), convertExpression(fragment.getInitializer())); + if (!peek().equals(expected)) { + throw new IllegalArgumentException("Expected '" + expected + "' at " + offset + ", got " + peek()); } - - t.setEndToken(firstTokenAfter(fragment, i + 1 < fieldDeclaration.fragments().size() ? TerminalToken.TokenNameCOMMA : TerminalToken.TokenNameSEMICOLON)); - setSymbol(t, fragment.resolveBinding()); - declaration(variableBinding(t), t); - - members.add(t); + return take(); } - return tokenManager.lastIndexIn(fieldDeclaration, TerminalToken.TokenNameSEMICOLON); - } - private ArgumentListTreeImpl convertArguments(@Nullable InternalSyntaxToken openParen, List list, @Nullable InternalSyntaxToken closeParen) { - ArgumentListTreeImpl arguments = ArgumentListTreeImpl.emptyList().complete(openParen, closeParen); - for (int i = 0; i < list.size(); i++) { - Expression o = (Expression) list.get(i); - arguments.add(convertExpression(o)); - if (i < list.size() - 1) { - arguments.separators().add(firstTokenAfter(o, TerminalToken.TokenNameCOMMA)); + List annotations() { + List result = new ArrayList<>(); + while (more() && peek().equals("@")) { + var psi = JParser.this.annotations.get(current().start()); + if (psi == null) { + throw new IllegalArgumentException("Missing annotation PSI at " + offset); + } + result.add(annotation(psi)); + offset = end(psi); + consumedEnd = offset; } + return result; } - return arguments; - } - @Nullable - private TypeArgumentListTreeImpl convertTypeArguments(List list) { - if (list.isEmpty()) { - return null; - } - ASTNode last = (ASTNode) list.get(list.size() - 1); - int tokenIndex = tokenManager.firstIndexAfter(last, ANY_TOKEN); - while (isComment(tokenManager.get(tokenIndex))) { - tokenIndex++; - } - return convertTypeArguments( - firstTokenBefore((ASTNode) list.get(0), TerminalToken.TokenNameLESS), - list, - // TerminalToken.TokenNameUNSIGNED_RIGHT_SHIFT vs TerminalToken.TokenNameGREATER - createSpecialToken(tokenIndex) - ); - } - - private TypeArgumentListTreeImpl convertTypeArguments(InternalSyntaxToken l, List list, InternalSyntaxToken g) { - TypeArgumentListTreeImpl typeArguments = new TypeArgumentListTreeImpl(l, g); - for (int i = 0; i < list.size(); i++) { - Type o = (Type) list.get(i); - if (i > 0) { - typeArguments.separators().add(firstTokenBefore(o, TerminalToken.TokenNameCOMMA)); + TypeTree completeType() { + var result = type(); + if (more()) { + throw new IllegalArgumentException("Unconverted type syntax at UTF-16 offset " + offset); } - typeArguments.add(convertType(o)); + return result; } - return typeArguments; - } - private TypeParameterListTreeImpl convertTypeParameters(List list) { - if (list.isEmpty()) { - return new TypeParameterListTreeImpl(); + TypeTree type() { + return type(true); } - ASTNode last = (ASTNode) list.get(list.size() - 1); - int tokenIndex = tokenManager.firstIndexAfter(last, ANY_TOKEN); - while (isComment(tokenManager.get(tokenIndex))) { - tokenIndex++; - } - TypeParameterListTreeImpl t = new TypeParameterListTreeImpl( - firstTokenBefore((ASTNode) list.get(0), TerminalToken.TokenNameLESS), - // TerminalToken.TokenNameUNSIGNED_RIGHT_SHIFT vs TerminalToken.TokenNameGREATER - createSpecialToken(tokenIndex) - ); - for (int i = 0; i < list.size(); i++) { - TypeParameter o = (TypeParameter) list.get(i); - if (i > 0) { - t.separators().add(firstTokenBefore(o, TerminalToken.TokenNameCOMMA)); + + private TypeTree type(boolean union) { + var leading = annotations(); + String keyword = peek(); + TypeTree result; + if (keyword.equals("?")) { + var question = take(); + JavaTree.WildcardTreeImpl wildcard; + if (more() && (peek().equals("extends") || peek().equals("super"))) { + var bound = take(); + wildcard = new JavaTree.WildcardTreeImpl(bound.text().equals("extends") ? Tree.Kind.EXTENDS_WILDCARD : Tree.Kind.SUPER_WILDCARD, bound, type()).complete(question); + } else { + wildcard = new JavaTree.WildcardTreeImpl(question); + } + wildcard.complete(leading); + return wildcard; + } + if (List.of("boolean", "byte", "char", "short", "int", "long", "float", "double", "void").contains(keyword)) { + var primitive = new JavaTree.PrimitiveTypeTreeImpl(take()); + primitive.complete(leading); + result = primitive; + } else { + JavaTree.AnnotatedTypeTree named = keyword.equals("var") ? new VarTypeTreeImpl(take()) : new IdentifierTreeImpl(take()); + named.complete(leading); + result = named; + while (more()) { + if (peek().equals("<")) { + result = new JavaTree.ParameterizedTypeTreeImpl(result, arguments()); + } else if (peek().equals(".")) { + var dot = take(); + var annotated = annotations(); + var identifier = new IdentifierTreeImpl(take()); + identifier.complete(annotated); + result = new MemberSelectExpressionTreeImpl((ExpressionTree) result, dot, identifier); + } else { + break; + } + } } - t.add(convertTypeParameter(o)); + while (includeDimensions && more() && (peek().equals("[") || peek().equals("...") || peek().equals("@"))) { + var annotated = annotations(); + if (peek().equals("...")) { + result = new JavaTree.ArrayTypeTreeImpl(result, (List) annotated, take()); + } else { + var left = take("["); + result = new JavaTree.ArrayTypeTreeImpl(result, (List) annotated, left, take("]")); + } + } + if (union && more() && peek().equals("|")) { + var alternatives = QualifiedIdentifierListTreeImpl.emptyList(); + alternatives.add(result); + while (more() && peek().equals("|")) { + alternatives.separators().add(take()); + alternatives.add(type(false)); + } + return new JavaTree.UnionTypeTreeImpl(alternatives); + } + return result; } - return t; - } - private TypeParameterTree convertTypeParameter(TypeParameter e) { - IdentifierTreeImpl i = createSimpleName(e.getName()); - // TODO why ECJ uses IExtendedModifier here instead of Annotation ? - i.complete(convertAnnotations(e.modifiers())); - TypeParameterTreeImpl t; - List typeBounds = e.typeBounds(); - if (typeBounds.isEmpty()) { - t = new TypeParameterTreeImpl(i); - } else { - QualifiedIdentifierListTreeImpl bounds = QualifiedIdentifierListTreeImpl.emptyList(); - for (int j = 0; j < typeBounds.size(); j++) { - Object o = typeBounds.get(j); - bounds.add(convertType((Type) o)); - if (j < typeBounds.size() - 1) { - bounds.separators().add(firstTokenAfter((ASTNode) o, TerminalToken.TokenNameAND)); + TypeArgumentListTreeImpl arguments() { + return arguments(true); + } + + /** Retains the reference frontend's synthetic bracket positions, including comment-adjacent and nested brackets. */ + TypeArgumentListTreeImpl arguments(boolean typeSyntax) { + var left = take("<"); + List arguments = new ArrayList<>(); + List separators = new ArrayList<>(); + while (!peek().startsWith(">")) { + arguments.add(type()); + if (!peek().equals(",")) { + break; } + separators.add(take()); } - t = new TypeParameterTreeImpl( - i, - firstTokenAfter(e.getName(), TerminalToken.TokenNameextends), - bounds - ); - } - setType(t, e.resolveBinding()); - return t; - } - - /** - * @param extraDimensions list of {@link org.eclipse.jdt.core.dom.Dimension} - */ - private TypeTree applyExtraDimensions(TypeTree type, List extraDimensions) { - ITypeBinding typeBinding = typeBinding(type); - for (int i = 0; i < extraDimensions.size(); i++) { - Dimension e = (Dimension) extraDimensions.get(i); - type = new JavaTree.ArrayTypeTreeImpl( - type, - (List) convertAnnotations(e.annotations()), - firstTokenIn(e, TerminalToken.TokenNameLBRACKET), - firstTokenIn(e, TerminalToken.TokenNameRBRACKET) - ); - if (typeBinding != null) { - setType(((JavaTree.ArrayTypeTreeImpl) type), typeBinding.createArrayType(i + 1)); + int logicalEnd = consumedEnd + 1; + boolean inheritedPosition = consumedEnd != physicalEnd; + var close = take(">"); + if (typeSyntax) { + logicalEnd = inheritedPosition || !close.trivias().isEmpty() ? logicalEnd : physicalEnd; + var pos = positions.toPos(logicalEnd - 1); + close = new InternalSyntaxToken(pos.line(), pos.columnOffset(), ">", List.of(), false); + consumedEnd = logicalEnd; } + var result = new TypeArgumentListTreeImpl(left, close); + result.addAll(arguments); + result.separators().addAll(separators); + return result; } - return type; } - private VariableTreeImpl convertVariable(TypePattern typePattern) { - if (typePattern.getAST().apiLevel() < AST.JLS22) { - return convertVariable(typePattern.getPatternVariable()); + private ClassTreeImpl classTree(PsiClass cls) { + List members = new ArrayList<>(); + for (var child : cls.getChildren()) { + if (child instanceof PsiEnumConstant constant) { + members.add(enumConstant(constant)); + } else if (child instanceof PsiField field) { + var variable = variable(field); + if (field.getLastChild() != null && field.getLastChild().textMatches(";")) { + variable.setEndToken(last(field, ";")); + } else { + var separator = tokens.at(end(field)); + if (separator.text().equals(",") || separator.text().equals(";")) { + variable.setEndToken(separator); + } + } + members.add(variable); + } else if (child instanceof PsiMethod method) { + members.add(method(method)); + } else if (child instanceof PsiClass nested) { + members.add(classTree(nested)); + } else if (child instanceof PsiClassInitializer initializer) { + var block = block(initializer.getBody()); + members.add(initializer.hasModifierProperty("static") + ? new StaticInitializerTreeImpl(token(initializer, "static"), (InternalSyntaxToken) block.openBraceToken(), block.body(), (InternalSyntaxToken) block.closeBraceToken()) + : new BlockTreeImpl(Tree.Kind.INITIALIZER, (InternalSyntaxToken) block.openBraceToken(), block.body(), (InternalSyntaxToken) block.closeBraceToken())); + } else if (child instanceof PsiJavaToken && child.textMatches(";")) { + var previous = PsiTreeUtil.skipWhitespacesAndCommentsBackward(child); + boolean enumSeparator = cls.isEnum() && previous != null && (previous.textMatches(",") || previous instanceof PsiEnumConstant); + if (!enumSeparator && (!(previous instanceof PsiField field) || field.getLastChild().textMatches(";"))) { + members.add(new EmptyStatementTreeImpl(exact(child))); + } + } } - VariableDeclaration variableDeclaration = typePattern.getPatternVariable2(); - if (variableDeclaration instanceof VariableDeclarationFragment declarationFragment) { - return convertVariable(declarationFragment); - } else { - return convertVariable((SingleVariableDeclaration) variableDeclaration); + if (cls instanceof PsiImplicitClass) { + return remember(cls, new ClassTreeImpl(Tree.Kind.IMPLICIT_CLASS, null, members, null)); + } + var kind = cls.isAnnotationType() ? Tree.Kind.ANNOTATION_TYPE : cls.isEnum() ? Tree.Kind.ENUM + : cls.isRecord() ? Tree.Kind.RECORD : cls.isInterface() ? Tree.Kind.INTERFACE : Tree.Kind.CLASS; + var tree = new ClassTreeImpl(kind, exact(cls.getLBrace()), members, exact(cls.getRBrace())); + if (!(cls instanceof PsiAnonymousClass)) { + String keyword = cls.isAnnotationType() || cls.isInterface() ? "interface" : cls.isEnum() ? "enum" : cls.isRecord() ? "record" : "class"; + tree.complete(modifiers(cls.getModifierList()), tokens.find(cls.getModifierList() == null ? start(cls) : end(cls.getModifierList()), start(cls.getNameIdentifier()), keyword, false), identifier(cls.getNameIdentifier())); + if (cls.isAnnotationType()) { + tree.completeAtToken(tokens.find(cls.getModifierList() == null ? start(cls) : end(cls.getModifierList()), start(cls.getNameIdentifier()), "@", false)); + } else if (!cls.isEnum()) { + tree.completeTypeParameters(typeParameters(cls.getTypeParameterList())); + } + var extendsList = cls.getExtendsList(); + var implementsList = cls.getImplementsList(); + if (extendsList != null && extendsList.getReferenceElements().length > 0) { + if (cls.isInterface()) { + tree.completeInterfaces(token(extendsList, "extends"), typeReferences(extendsList)); + } else { + var reference = extendsList.getReferenceElements()[0]; + tree.completeSuperclass(token(extendsList, "extends"), typeReference(reference)); + } + } + if (implementsList != null && implementsList.getReferenceElements().length > 0) { + tree.completeInterfaces(token(implementsList, "implements"), typeReferences(implementsList)); + } + var permits = cls.getPermitsList(); + if (permits != null && permits.getReferenceElements().length > 0) { + tree.completePermittedTypes(token(permits, "permits"), typeReferences(permits)); + } + var header = cls.getRecordHeader(); + if (header != null) { + List components = new ArrayList<>(); + for (var component : header.getRecordComponents()) { + var variable = variable(component); + if (tokens.at(end(component)).text().equals(",")) { + variable.setEndToken(tokens.at(end(component))); + } + components.add(variable); + } + tree.completeRecordComponents(token(header, "("), components, last(header, ")")); + } } + return remember(cls, tree); } - private VariableTreeImpl convertVariable(VariableDeclarationFragment declarationFragment) { - return completeInitializerAndBinding( - new VariableTreeImpl(createSimpleName(declarationFragment.getName())), - declarationFragment); + private TypeTree typeReference(PsiJavaCodeReferenceElement reference) { + return remember(reference, new TypeCursor(start(reference), end(reference)).completeType()); } - private VariableTreeImpl convertVariable(SingleVariableDeclaration e) { - // TODO are extraDimensions and varargs mutually exclusive? - TypeTree type = convertType(e.getType()); - type = applyExtraDimensions(type, e.extraDimensions()); - if (e.isVarargs()) { - ITypeBinding typeBinding = typeBinding(type); - type = new JavaTree.ArrayTypeTreeImpl( - type, - (List) convertAnnotations(e.varargsAnnotations()), - firstTokenAfter(e.getType(), TerminalToken.TokenNameELLIPSIS) - ); - if (typeBinding != null) { - setType(((JavaTree.ArrayTypeTreeImpl) type), typeBinding.createArrayType(1)); + private QualifiedIdentifierListTreeImpl typeReferences(PsiReferenceList source) { + var result = QualifiedIdentifierListTreeImpl.emptyList(); + if (source != null) { + for (var reference : source.getReferenceElements()) { + if (!result.isEmpty()) { + result.separators().add(tokens.find(start(source), start(reference), ",", true)); + } + result.add(typeReference(reference)); } } - - VariableTreeImpl t = new VariableTreeImpl( - convertModifiers(e.modifiers()), - type, - createSimpleName(e.getName()) - ); - return completeInitializerAndBinding(t, e); + return result; } - private VariableTreeImpl completeInitializerAndBinding(VariableTreeImpl t, VariableDeclaration e) { - if (e.getInitializer() != null) { - t.completeTypeAndInitializer( - t.type(), - firstTokenAfter(e.getName(), TerminalToken.TokenNameEQUAL), - convertExpression(e.getInitializer()) - ); + private TypeParameterListTreeImpl typeParameters(PsiTypeParameterList source) { + if (source == null || source.getTypeParameters().length == 0) { + return new TypeParameterListTreeImpl(); } - setSymbol(t, e.resolveBinding()); - if (variableBinding(t) != null) { - if (t.type() instanceof InferedTypeTree inferredType) { - setType(inferredType, variableBinding(t).getType()); + var result = new TypeParameterListTreeImpl(token(source, "<"), tokens.slice(end(source) - 1, end(source))); + for (var parameter : source.getTypeParameters()) { + if (!result.isEmpty()) { + result.separators().add(tokens.find(start(source), start(parameter), ",", true)); + } + var name = identifier(parameter.getNameIdentifier()); + name.complete(Arrays.stream(parameter.getAnnotations()).map(a -> (AnnotationTree) annotation(a)).toList()); + var references = parameter.getExtendsList().getReferenceElements(); + TypeParameterTreeImpl tree; + if (references.length == 0) { + tree = new TypeParameterTreeImpl(name); + } else { + var bounds = QualifiedIdentifierListTreeImpl.emptyList(); + for (var reference : references) { + if (!bounds.isEmpty()) { + bounds.separators().add(tokens.find(start(parameter), start(reference), "&", true)); + } + bounds.add(typeReference(reference)); + } + tree = new TypeParameterTreeImpl(name, token(parameter, "extends"), bounds); } - declaration(variableBinding(t), t); + result.add(remember(parameter, tree)); } - return t; + return result; } - private void addVariableToList(VariableDeclarationExpression e2, List list) { - ModifiersTreeImpl modifiers = convertModifiers(e2.modifiers()); - TypeTree type = convertType(e2.getType()); + private final Map sharedTypes = new IdentityHashMap<>(); + private final Map sharedModifiers = new IdentityHashMap<>(); - for (int i = 0; i < e2.fragments().size(); i++) { - VariableDeclarationFragment fragment = (VariableDeclarationFragment) e2.fragments().get(i); - VariableTreeImpl t = new VariableTreeImpl(createSimpleName(fragment.getName())); - t.completeModifiers(modifiers); - if (fragment.getInitializer() == null) { - t.completeType(applyExtraDimensions(type, fragment.extraDimensions())); - } else { - t.completeTypeAndInitializer( - applyExtraDimensions(type, fragment.extraDimensions()), - firstTokenBefore(fragment.getInitializer(), TerminalToken.TokenNameEQUAL), - convertExpression(fragment.getInitializer()) - ); - } - if (i < e2.fragments().size() - 1) { - t.setEndToken(firstTokenAfter(fragment, TerminalToken.TokenNameCOMMA)); - } - setSymbol(t, fragment.resolveBinding()); - declaration(variableBinding(t), t); - list.add(t); + private VariableTreeImpl variable(PsiVariable variable) { + var name = identifier(variable.getNameIdentifier()); + var sourceType = variable.getTypeElement(); + TypeTree type = sourceType == null ? new InferedTypeTree() : sharedTypes.computeIfAbsent(sourceType, this::typeElement); + int afterName = end(variable.getNameIdentifier()); + int limit = variable.getInitializer() == null ? end(variable) : start(variable.getInitializer()); + type = dimensions(type, afterName, limit); + var modifiers = sharedModifiers.computeIfAbsent(variable.getModifierList(), this::modifiers); + var result = new VariableTreeImpl(modifiers, type, name); + if (variable.getInitializer() != null) { + result.completeTypeAndInitializer(type, tokens.find(afterName, start(variable.getInitializer()), "=", false), expression(variable.getInitializer())); } + return remember(variable, result); } - private VarTypeTreeImpl convertVarType(SimpleType simpleType) { - VarTypeTreeImpl varTree = new VarTypeTreeImpl(firstTokenIn(simpleType.getName(), TerminalToken.TokenNameIdentifier)); - setType(varTree, simpleType.resolveBinding()); - return varTree; + private TypeTree typeElement(PsiElement element) { + return type((PsiTypeElement) element); } - private IdentifierTreeImpl createSimpleName(SimpleName e) { - int tokenIndex = firstIndexIn(tokenManager, e, TerminalToken.TokenNameIdentifier, TerminalToken.TokenNameUNDERSCORE); - Token token = tokenManager.get(tokenIndex); - boolean isUnnamedVariable = token.tokenType == TerminalToken.TokenNameUNDERSCORE; - IdentifierTreeImpl t = new IdentifierTreeImpl(createSyntaxToken(tokenIndex), isUnnamedVariable); - setType(t, e.resolveTypeBinding()); - setSymbol(t, e.resolveBinding()); - return t; + private TypeTree dimensions(TypeTree type, int offset, int limit) { + var cursor = new TypeCursor(offset, limit); + while (cursor.more() && (cursor.peek().equals("[") || cursor.peek().equals("@"))) { + var annotations = cursor.annotations(); + var open = cursor.take("["); + type = new JavaTree.ArrayTypeTreeImpl(type, (List) annotations, open, cursor.take("]")); + } + return type; } - private BlockTreeImpl convertBlock(Block e) { - List statements = new ArrayList<>(); - for (Object o : e.statements()) { - addStatementToList((Statement) o, statements); - } - return new BlockTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameLBRACE), - statements, - lastTokenIn(e, TerminalToken.TokenNameRBRACE) - ); - } - - private void addStatementToList(Statement node, List statements) { - if (node.getNodeType() == ASTNode.VARIABLE_DECLARATION_STATEMENT) { - VariableDeclarationStatement e = (VariableDeclarationStatement) node; - TypeTree tType = convertType(e.getType()); - ModifiersTreeImpl modifiers = convertModifiers(e.modifiers()); - for (int i = 0; i < e.fragments().size(); i++) { - VariableDeclarationFragment fragment = (VariableDeclarationFragment) e.fragments().get(i); - VariableTreeImpl t = new VariableTreeImpl(createSimpleName(fragment.getName())) - .completeType(applyExtraDimensions(tType, fragment.extraDimensions())) - .completeModifiers(modifiers); - Expression initalizer = fragment.getInitializer(); - if (initalizer != null) { - InternalSyntaxToken equalToken = firstTokenAfter(fragment.getName(), TerminalToken.TokenNameEQUAL); - t.completeTypeAndInitializer(t.type(), equalToken, convertExpression(initalizer)); - } - TerminalToken endTokenType = i < e.fragments().size() - 1 ? TerminalToken.TokenNameCOMMA : TerminalToken.TokenNameSEMICOLON; - t.setEndToken(firstTokenAfter(fragment, endTokenType)); - - setSymbol(t, fragment.resolveBinding()); - declaration(variableBinding(t), t); - statements.add(t); + private MethodTreeImpl method(PsiMethod method) { + var sourceParameters = method.getParameterList(); + boolean hasParentheses = sourceParameters.getText() != null && sourceParameters.getText().startsWith("("); + var parameters = new FormalParametersListTreeImpl(hasParentheses ? token(sourceParameters, "(") : null, hasParentheses ? last(sourceParameters, ")") : null); + for (var parameter : hasParentheses ? sourceParameters.getParameters() : PsiParameter.EMPTY_ARRAY) { + var variable = variable(parameter); + if (tokens.at(end(parameter)).text().equals(",")) { + variable.setEndToken(tokens.at(end(parameter))); } + parameters.add(variable); + } + var returnType = method.isConstructor() ? null : dimensions(type(method.getReturnTypeElement()), (hasParentheses ? end(sourceParameters) : end(method.getNameIdentifier())), + method.getBody() == null ? end(method) : start(method.getBody())); + MethodTreeImpl result; + if (method instanceof PsiAnnotationMethod annotationMethod) { + var value = annotationMethod.getDefaultValue(); + result = new MethodTreeImpl(parameters, value == null ? null : token(method, "default"), value == null ? null : expression(value)) + .complete(returnType, identifier(method.getNameIdentifier()), last(method, ";")); } else { - statements.add(createStatement(node)); - } - } - - private StatementTree createStatement(Statement node) { - switch (node.getNodeType()) { - case ASTNode.BLOCK: - return convertBlock((Block) node); - case ASTNode.EMPTY_STATEMENT: - return convertEmptyStatement((EmptyStatement) node); - case ASTNode.RETURN_STATEMENT: - return convertReturn((ReturnStatement) node); - case ASTNode.FOR_STATEMENT: - return convertFor((ForStatement) node); - case ASTNode.WHILE_STATEMENT: - return convertWhile((WhileStatement) node); - case ASTNode.IF_STATEMENT: - return convertIf((IfStatement) node); - case ASTNode.BREAK_STATEMENT: - return convertBreak((BreakStatement) node); - case ASTNode.DO_STATEMENT: - return convertDoWhile((DoStatement) node); - case ASTNode.ASSERT_STATEMENT: - return convertAssert((AssertStatement) node); - case ASTNode.SWITCH_STATEMENT: - return convertSwitchStatement((SwitchStatement) node); - case ASTNode.SYNCHRONIZED_STATEMENT: - return convertSynchronized((SynchronizedStatement) node); - case ASTNode.EXPRESSION_STATEMENT: - return convertExpressionStatement((ExpressionStatement) node); - case ASTNode.CONTINUE_STATEMENT: - return convertContinue((ContinueStatement) node); - case ASTNode.LABELED_STATEMENT: - return convertLabel((LabeledStatement) node); - case ASTNode.ENHANCED_FOR_STATEMENT: - return convertForeach((EnhancedForStatement) node); - case ASTNode.THROW_STATEMENT: - return convertThrow((ThrowStatement) node); - case ASTNode.TRY_STATEMENT: - return convertTry((TryStatement) node); - case ASTNode.TYPE_DECLARATION_STATEMENT: - return convertTypeDeclaration(((TypeDeclarationStatement) node).getDeclaration()); - case ASTNode.CONSTRUCTOR_INVOCATION: - return convertConstructorInvocation((ConstructorInvocation) node); - case ASTNode.SUPER_CONSTRUCTOR_INVOCATION: - return convertSuperConstructorInvocation((SuperConstructorInvocation) node); - case ASTNode.YIELD_STATEMENT: - return convertYield((YieldStatement) node); - default: - throw new IllegalStateException(ASTNode.nodeClassForType(node.getNodeType()).toString()); - } - } - - private EmptyStatementTreeImpl convertEmptyStatement(EmptyStatement e) { - return new EmptyStatementTreeImpl(lastTokenIn(e, TerminalToken.TokenNameSEMICOLON)); - } - - private ReturnStatementTreeImpl convertReturn(ReturnStatement e) { - Expression expression = e.getExpression(); - return new ReturnStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNamereturn), - expression == null ? null : convertExpression(expression), - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - - private ForStatementTreeImpl convertFor(ForStatement e) { - StatementListTreeImpl forInitStatement = StatementListTreeImpl.emptyList(); - for (int i = 0; i < e.initializers().size(); i++) { - Expression o = (Expression) e.initializers().get(i); - if (i > 0) { - forInitStatement.separators().add(firstTokenBefore(o, TerminalToken.TokenNameCOMMA)); + var exceptions = typeReferences(method.getThrowsList()); + result = new MethodTreeImpl(returnType, identifier(method.getNameIdentifier()), parameters, + exceptions.isEmpty() ? null : token(method.getThrowsList(), "throws"), exceptions, + method.getBody() == null ? null : block(method.getBody()), method.getBody() == null ? last(method, ";") : null) + .completeWithTypeParameters(typeParameters(method.getTypeParameterList())); + } + return remember(method, result.completeWithModifiers(modifiers(method.getModifierList()))); + } + + private EnumConstantTreeImpl enumConstant(PsiEnumConstant constant) { + var name = identifier(constant.getNameIdentifier()); + var separator = tokens.at(end(constant)); + return remember(constant, new EnumConstantTreeImpl(modifiers(constant.getModifierList()), name, + new NewClassTreeImpl(name, arguments(constant.getArgumentList()), constant.getInitializingClass() == null ? null : classTree(constant.getInitializingClass())), + separator.text().equals(",") || separator.text().equals(";") ? separator : null)); + } + + private AnnotationTreeImpl annotation(PsiAnnotation annotation) { + var arguments = ArgumentListTreeImpl.emptyList(); + var attributes = annotation.getParameterList().getAttributes(); + for (var attribute : attributes) { + ExpressionTree value = expression(attribute.getValue()); + if (attribute.getNameIdentifier() != null) { + value = new AssignmentExpressionTreeImpl(Tree.Kind.ASSIGNMENT, identifier(attribute.getNameIdentifier()), token(attribute, "="), value); } - if (ASTNode.VARIABLE_DECLARATION_EXPRESSION == o.getNodeType()) { - addVariableToList((VariableDeclarationExpression) o, forInitStatement); - } else { - forInitStatement.add(new ExpressionStatementTreeImpl(convertExpression(o), null)); + arguments.add(value); + if (tokens.at(end(attribute)).text().equals(",")) { + arguments.separators().add(tokens.at(end(attribute))); } } + if (annotation.getParameterList().getText().startsWith("(")) { + arguments.complete(token(annotation.getParameterList(), "("), last(annotation.getParameterList(), ")")); + } + return remember(annotation, new AnnotationTreeImpl(token(annotation, "@"), (TypeTree) name(annotation.getNameReferenceElement()), arguments)); + } + + private ExpressionTree expression(PsiElement element) { + if (element == null) { + throw new IllegalArgumentException("Missing expression"); + } + ExpressionTree result = switch (element) { + case PsiAnnotation annotation -> annotation(annotation); + case PsiMethodReferenceExpression reference -> methodReference(reference); + case PsiReferenceExpression reference -> reference(reference); + case PsiLiteralExpression literal -> literal(literal); + case PsiParenthesizedExpression parenthesized -> new ParenthesizedTreeImpl(token(parenthesized, "("), expression(parenthesized.getExpression()), last(parenthesized, ")")); + case PsiAssignmentExpression assignment -> new AssignmentExpressionTreeImpl(operator(PsiTokenIndex.decoded(assignment.getOperationSign().getText()), false, false), + expression(assignment.getLExpression()), exact(assignment.getOperationSign()), expression(assignment.getRExpression())); + case PsiPolyadicExpression polyadic -> binary(polyadic); + case PsiPrefixExpression prefix -> new InternalPrefixUnaryExpression(operator(PsiTokenIndex.decoded(prefix.getOperationSign().getText()), true, false), exact(prefix.getOperationSign()), expression(prefix.getOperand())); + case PsiPostfixExpression postfix -> new InternalPostfixUnaryExpression(operator(PsiTokenIndex.decoded(postfix.getOperationSign().getText()), true, true), expression(postfix.getOperand()), exact(postfix.getOperationSign())); + case PsiConditionalExpression conditional -> new ConditionalExpressionTreeImpl(expression(conditional.getCondition()), + tokens.find(end(conditional.getCondition()), start(conditional.getThenExpression()), "?", false), expression(conditional.getThenExpression()), + tokens.find(end(conditional.getThenExpression()), start(conditional.getElseExpression()), ":", false), expression(conditional.getElseExpression())); + case PsiMethodCallExpression call -> new MethodInvocationTreeImpl(reference(call.getMethodExpression()), typeArguments(call.getTypeArgumentList()), arguments(call.getArgumentList())); + case PsiNewExpression creation -> newExpression(creation); + case PsiArrayInitializerExpression initializer -> arrayInitializer(initializer, initializer.getInitializers()); + case PsiArrayInitializerMemberValue initializer -> arrayInitializer(initializer, initializer.getInitializers()); + case PsiArrayAccessExpression access -> new ArrayAccessExpressionTreeImpl(expression(access.getArrayExpression()), new ArrayDimensionTreeImpl( + tokens.find(end(access.getArrayExpression()), start(access.getIndexExpression()), "[", false), expression(access.getIndexExpression()), last(access, "]"))); + case PsiTypeCastExpression cast -> cast(cast); + case PsiInstanceOfExpression instanceOf -> instanceOf.getPattern() == null + ? new InstanceOfTreeImpl(expression(instanceOf.getOperand()), token(instanceOf, "instanceof"), type(instanceOf.getCheckType())) + : new InstanceOfTreeImpl(expression(instanceOf.getOperand()), token(instanceOf, "instanceof"), pattern(instanceOf.getPattern())); + case PsiThisExpression thisExpression -> keyword(thisExpression, "this"); + case PsiSuperExpression superExpression -> keyword(superExpression, "super"); + case PsiClassObjectAccessExpression access -> new MemberSelectExpressionTreeImpl((ExpressionTree) type(access.getOperand()), last(access, "."), new IdentifierTreeImpl(last(access, "class"))); + case PsiLambdaExpression lambda -> lambda(lambda); + case PsiSwitchExpression expression -> switchExpression(expression); + default -> throw unsupported(element); + }; + return remember(element, result); + } - StatementListTreeImpl forUpdateStatement = StatementListTreeImpl.emptyList(); - for (int i = 0; i < e.updaters().size(); i++) { - Expression o = (Expression) e.updaters().get(i); - if (i > 0) { - forUpdateStatement.separators().add(firstTokenBefore(o, TerminalToken.TokenNameCOMMA)); - } - forUpdateStatement.add(new ExpressionStatementTreeImpl(convertExpression(o), null)); - } - - final int firstSemicolonTokenIndex = e.initializers().isEmpty() - ? tokenManager.firstIndexIn(e, TerminalToken.TokenNameSEMICOLON) - : tokenManager.firstIndexAfter((ASTNode) e.initializers().get(e.initializers().size() - 1), TerminalToken.TokenNameSEMICOLON); - Expression expression = e.getExpression(); - final int secondSemicolonTokenIndex = expression == null - ? nextTokenIndex(firstSemicolonTokenIndex, TerminalToken.TokenNameSEMICOLON) - : tokenManager.firstIndexAfter(expression, TerminalToken.TokenNameSEMICOLON); - - return new ForStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNamefor), - firstTokenIn(e, TerminalToken.TokenNameLPAREN), - forInitStatement, - createSyntaxToken(firstSemicolonTokenIndex), - expression == null ? null : convertExpression(expression), - createSyntaxToken(secondSemicolonTokenIndex), - forUpdateStatement, - firstTokenBefore(e.getBody(), TerminalToken.TokenNameRPAREN), - createStatement(e.getBody()) - ); - } - - private WhileStatementTreeImpl convertWhile(WhileStatement e) { - Expression expression = e.getExpression(); - return new WhileStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNamewhile), - firstTokenBefore(expression, TerminalToken.TokenNameLPAREN), - convertExpression(expression), - firstTokenAfter(expression, TerminalToken.TokenNameRPAREN), - createStatement(e.getBody()) - ); - } - - private IfStatementTreeImpl convertIf(IfStatement e) { - Expression expression = e.getExpression(); - Statement thenStatement = e.getThenStatement(); - Statement elseStatement = e.getElseStatement(); - return new IfStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameif), - firstTokenBefore(expression, TerminalToken.TokenNameLPAREN), - convertExpression(expression), - firstTokenAfter(expression, TerminalToken.TokenNameRPAREN), - createStatement(thenStatement), - elseStatement == null ? null : firstTokenAfter(thenStatement, TerminalToken.TokenNameelse), - elseStatement == null ? null : createStatement(elseStatement) - ); - } - - private BreakStatementTreeImpl convertBreak(BreakStatement e) { - IdentifierTreeImpl identifier = e.getLabel() == null ? null : createSimpleName(e.getLabel()); - usageLabel(identifier); - return new BreakStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNamebreak), - identifier, - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - - private DoWhileStatementTreeImpl convertDoWhile(DoStatement e) { - Statement body = e.getBody(); - Expression expression = e.getExpression(); - return new DoWhileStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNamedo), - createStatement(body), - firstTokenAfter(body, TerminalToken.TokenNamewhile), - firstTokenBefore(expression, TerminalToken.TokenNameLPAREN), - convertExpression(expression), - firstTokenAfter(expression, TerminalToken.TokenNameRPAREN), - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - - private AssertStatementTreeImpl convertAssert(AssertStatement e) { - Expression message = e.getMessage(); - AssertStatementTreeImpl t = new AssertStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameassert), - convertExpression(e.getExpression()), - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - if (message != null) { - t.complete(firstTokenBefore(message, TerminalToken.TokenNameCOLON), convertExpression(message)); - } - return t; - } - - private SwitchStatementTreeImpl convertSwitchStatement(SwitchStatement e) { - Expression expression = e.getExpression(); - return new SwitchStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameswitch), - firstTokenBefore(expression, TerminalToken.TokenNameLPAREN), - convertExpression(expression), - firstTokenAfter(expression, TerminalToken.TokenNameRPAREN), - firstTokenAfter(expression, TerminalToken.TokenNameLBRACE), - convertSwitchStatements(e.statements()), - lastTokenIn(e, TerminalToken.TokenNameRBRACE) - ); - } - - private List convertSwitchStatements(List list) { - List groups = new ArrayList<>(); - List caselabels = null; - StatementListTreeImpl body = null; - - for (Object o : list) { - if (o instanceof SwitchCase c) { - if (caselabels == null) { - caselabels = new ArrayList<>(); - body = StatementListTreeImpl.emptyList(); - } + private IllegalArgumentException unsupported(PsiElement element) { + return new IllegalArgumentException("Unsupported PSI syntax: " + element.getClass().getName() + " at " + start(element) + ": " + element.getText()); + } - List expressions = ((List) c.expressions()).stream() - .map(Expression.class::cast) - .map(this::convertExpressionFromCase) - .toList(); + private ExpressionTree reference(PsiReferenceExpression reference) { + var name = identifier(reference.getReferenceNameElement()); + var qualifier = reference.getQualifierExpression(); + return qualifier == null ? name : new MemberSelectExpressionTreeImpl(expression(qualifier), + tokens.find(end(qualifier), start(reference.getReferenceNameElement()), ".", false), name); + } - caselabels.add(new CaseLabelTreeImpl( - firstTokenIn(c, c.isDefault() ? TerminalToken.TokenNamedefault : TerminalToken.TokenNamecase), - expressions, - lastTokenIn(c, /* TerminalToken.TokenNameCOLON or TerminalToken.TokenNameARROW */ ANY_TOKEN) - )); - } else { - if (caselabels != null) { - groups.add(new CaseGroupTreeImpl(caselabels, body)); - } - caselabels = null; - addStatementToList((Statement) o, Objects.requireNonNull(body)); - } - } - if (caselabels != null) { - groups.add(new CaseGroupTreeImpl(caselabels, body)); - } - return groups; - } - - private ExpressionTree convertExpressionFromCase(Expression e) { - if (e.getNodeType() == ASTNode.CASE_DEFAULT_EXPRESSION) { - return new DefaultPatternTreeImpl(firstTokenIn(e, TerminalToken.TokenNamedefault), sema.typeSupplier(e.resolveTypeBinding())); - } - if (e.getNodeType() == ASTNode.NULL_LITERAL) { - return new NullPatternTreeImpl((LiteralTreeImpl) convertExpression(e)); - } - if (e instanceof Pattern pattern) { - return convertPattern(pattern); - } - return convertExpression(e); - } - - private PatternTree convertPattern(Pattern p) { - switch (p.getNodeType()) { - case ASTNode.TYPE_PATTERN: - TypePattern typePattern = (TypePattern) p; - return new TypePatternTreeImpl(convertVariable(typePattern), sema.typeSupplier(typePattern.resolveTypeBinding())); - case ASTNode.RECORD_PATTERN: - RecordPattern recordPattern = (RecordPattern) p; - List nestedPatterns = recordPattern.patterns().stream() - .map(this::convertPattern) - .toList(); - - TypeTree patternType = convertType(recordPattern.getPatternType()); - var openParenToken = firstTokenIn(recordPattern, TerminalToken.TokenNameLPAREN); - var closeParenToken = lastTokenIn(recordPattern, TerminalToken.TokenNameRPAREN); - return new RecordPatternTreeImpl(patternType, openParenToken, nestedPatterns, closeParenToken); - case ASTNode.GUARDED_PATTERN: - GuardedPattern g = (GuardedPattern) p; - return new GuardedPatternTreeImpl( - convertPattern(g.getPattern()), - firstTokenBefore(g.getExpression(), TerminalToken.TokenNameRestrictedIdentifierWhen), - convertExpression(g.getExpression()), - sema.typeSupplier(g.resolveTypeBinding())); - case ASTNode.NULL_PATTERN: - // It is not clear how to reach this one, it seems to be possible only with badly constructed AST - // fall-through. Do nothing for now. - default: - // JEP-405 (not released as part of any JDK yet): ArrayPattern, RecordPattern - throw new IllegalStateException(ASTNode.nodeClassForType(p.getNodeType()).toString()); - } - } - - private SynchronizedStatementTreeImpl convertSynchronized(SynchronizedStatement e) { - Expression expression = e.getExpression(); - return new SynchronizedStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNamesynchronized), - firstTokenBefore(expression, TerminalToken.TokenNameLPAREN), - convertExpression(expression), - firstTokenAfter(expression, TerminalToken.TokenNameRPAREN), - convertBlock(e.getBody()) - ); - } - - private ExpressionStatementTreeImpl convertExpressionStatement(ExpressionStatement e) { - return new ExpressionStatementTreeImpl( - convertExpression(e.getExpression()), - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - - private ContinueStatementTreeImpl convertContinue(ContinueStatement e) { - SimpleName label = e.getLabel(); - IdentifierTreeImpl i = label == null ? null : createSimpleName(label); - usageLabel(i); - return new ContinueStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNamecontinue), - i, - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - - private LabeledStatementTreeImpl convertLabel(LabeledStatement e) { - IdentifierTreeImpl i = createSimpleName(e.getLabel()); - - JLabelSymbol symbol = new JLabelSymbol(i.name()); - labels.push(symbol); + private ExpressionTree keyword(PsiQualifiedExpression element, String keyword) { + var source = (PsiElement) element; + IdentifierTreeImpl name = keyword.equals("this") ? new KeywordThis(last(source, keyword)) : new KeywordSuper(last(source, keyword)); + var qualifier = element.getQualifier(); + return qualifier == null ? name : new MemberSelectExpressionTreeImpl(name(qualifier), last(source, "."), name); + } - LabeledStatementTreeImpl t = new LabeledStatementTreeImpl( - i, - firstTokenAfter(e.getLabel(), TerminalToken.TokenNameCOLON), - createStatement(e.getBody()) - ); + private LiteralTreeImpl literal(PsiLiteralExpression literal) { + var value = tokens.at(start(literal)); + String kind = literal.getFirstChild().getNode().getElementType().toString(); + Tree.Kind treeKind = switch (kind) { + case "INTEGER_LITERAL" -> Tree.Kind.INT_LITERAL; + case "LONG_LITERAL" -> Tree.Kind.LONG_LITERAL; + case "FLOAT_LITERAL" -> Tree.Kind.FLOAT_LITERAL; + case "DOUBLE_LITERAL" -> Tree.Kind.DOUBLE_LITERAL; + case "CHARACTER_LITERAL" -> Tree.Kind.CHAR_LITERAL; + case "TEXT_BLOCK_LITERAL" -> Tree.Kind.TEXT_BLOCK; + case "STRING_LITERAL" -> Tree.Kind.STRING_LITERAL; + case "TRUE_KEYWORD", "FALSE_KEYWORD" -> Tree.Kind.BOOLEAN_LITERAL; + case "NULL_KEYWORD" -> Tree.Kind.NULL_LITERAL; + default -> throw unsupported(literal); + }; + return new LiteralTreeImpl(treeKind, value); + } - labels.pop(); - symbol.declaration = t; - t.labelSymbol = symbol; - return t; - } - - private ForEachStatementImpl convertForeach(EnhancedForStatement e) { - SingleVariableDeclaration parameter = e.getParameter(); - Expression expression = e.getExpression(); - return new ForEachStatementImpl( - firstTokenIn(e, TerminalToken.TokenNamefor), - firstTokenBefore(parameter, TerminalToken.TokenNameLPAREN), - convertVariable(parameter), - firstTokenAfter(parameter, TerminalToken.TokenNameCOLON), - convertExpression(expression), - firstTokenAfter(expression, TerminalToken.TokenNameRPAREN), - createStatement(e.getBody()) - ); - } - - private ThrowStatementTreeImpl convertThrow(ThrowStatement e) { - return new ThrowStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNamethrow), - convertExpression(e.getExpression()), - firstTokenAfter(e.getExpression(), TerminalToken.TokenNameSEMICOLON) - ); - } - - private TryStatementTreeImpl convertTry(TryStatement e) { - ResourceListTreeImpl resources = convertResources(e); - List catches = convertCatchClauses(e); - - Block f = e.getFinally(); - return new TryStatementTreeImpl( - firstTokenIn(e, TerminalToken.TokenNametry), - resources.isEmpty() ? null : firstTokenIn(e, TerminalToken.TokenNameLPAREN), - resources, - resources.isEmpty() ? null : firstTokenBefore(e.getBody(), TerminalToken.TokenNameRPAREN), - convertBlock(e.getBody()), - catches, - f == null ? null : firstTokenBefore(f, TerminalToken.TokenNamefinally), - f == null ? null : convertBlock(f) - ); - } - - private ResourceListTreeImpl convertResources(TryStatement e) { - List r = e.resources(); - ResourceListTreeImpl resources = ResourceListTreeImpl.emptyList(); - for (int i = 0; i < r.size(); i++) { - Expression o = (Expression) r.get(i); - if (ASTNode.VARIABLE_DECLARATION_EXPRESSION == o.getNodeType()) { - addVariableToList((VariableDeclarationExpression) o, resources); - } else { - resources.add(convertExpression(o)); - } - addSeparatorToList(e, o, resources.separators(), i < e.resources().size() - 1); + private ExpressionTree binary(PsiPolyadicExpression polyadic) { + var operands = polyadic.getOperands(); + ExpressionTree result = expression(operands[0]); + for (int i = 1; i < operands.length; i++) { + var sign = polyadic.getTokenBeforeOperand(operands[i]); + result = new BinaryExpressionTreeImpl(operator(sign.getText(), false, false), result, exact(sign), expression(operands[i])); + var origin = i == operands.length - 1 ? polyadic : JavaPsiFacade.getElementFactory(file.getProject()).createExpressionFromText( + polyadic.getText().substring(0, operands[i].getTextRange().getEndOffset() - polyadic.getTextRange().getStartOffset()), polyadic); + remember(origin, result); } - return resources; + return result; } - private void addSeparatorToList(TryStatement tryStatement, Expression resource, List separators, boolean isLast) { - if (isLast) { - separators.add(firstTokenAfter(resource, TerminalToken.TokenNameSEMICOLON)); - } else { - int tokenIndex = tokenManager.firstIndexBefore(tryStatement.getBody(), TerminalToken.TokenNameRPAREN); - while (true) { - Token token; - do { - tokenIndex--; - token = tokenManager.get(tokenIndex); - } while (isComment(token)); - - if (token.tokenType != TerminalToken.TokenNameSEMICOLON) { - break; + private static Tree.Kind operator(String text, boolean unary, boolean postfix) { + if (unary) { + return switch (text) { + case "+" -> Tree.Kind.UNARY_PLUS; + case "-" -> Tree.Kind.UNARY_MINUS; + case "!" -> Tree.Kind.LOGICAL_COMPLEMENT; + case "~" -> Tree.Kind.BITWISE_COMPLEMENT; + case "++" -> postfix ? Tree.Kind.POSTFIX_INCREMENT : Tree.Kind.PREFIX_INCREMENT; + case "--" -> postfix ? Tree.Kind.POSTFIX_DECREMENT : Tree.Kind.PREFIX_DECREMENT; + default -> throw new IllegalArgumentException("Unknown unary operator " + text); + }; + } + return switch (text) { + case "*" -> Tree.Kind.MULTIPLY; + case "/" -> Tree.Kind.DIVIDE; + case "%" -> Tree.Kind.REMAINDER; + case "+" -> Tree.Kind.PLUS; + case "-" -> Tree.Kind.MINUS; + case "<<" -> Tree.Kind.LEFT_SHIFT; + case ">>" -> Tree.Kind.RIGHT_SHIFT; + case ">>>" -> Tree.Kind.UNSIGNED_RIGHT_SHIFT; + case "<" -> Tree.Kind.LESS_THAN; + case ">" -> Tree.Kind.GREATER_THAN; + case "<=" -> Tree.Kind.LESS_THAN_OR_EQUAL_TO; + case ">=" -> Tree.Kind.GREATER_THAN_OR_EQUAL_TO; + case "==" -> Tree.Kind.EQUAL_TO; + case "!=" -> Tree.Kind.NOT_EQUAL_TO; + case "^" -> Tree.Kind.XOR; + case "|" -> Tree.Kind.OR; + case "&" -> Tree.Kind.AND; + case "||" -> Tree.Kind.CONDITIONAL_OR; + case "&&" -> Tree.Kind.CONDITIONAL_AND; + case "=" -> Tree.Kind.ASSIGNMENT; + case "+=" -> Tree.Kind.PLUS_ASSIGNMENT; + case "-=" -> Tree.Kind.MINUS_ASSIGNMENT; + case "*=" -> Tree.Kind.MULTIPLY_ASSIGNMENT; + case "/=" -> Tree.Kind.DIVIDE_ASSIGNMENT; + case "%=" -> Tree.Kind.REMAINDER_ASSIGNMENT; + case "&=" -> Tree.Kind.AND_ASSIGNMENT; + case "|=" -> Tree.Kind.OR_ASSIGNMENT; + case "^=" -> Tree.Kind.XOR_ASSIGNMENT; + case "<<=" -> Tree.Kind.LEFT_SHIFT_ASSIGNMENT; + case ">>=" -> Tree.Kind.RIGHT_SHIFT_ASSIGNMENT; + case ">>>=" -> Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT; + default -> throw new IllegalArgumentException("Unknown binary operator " + text); + }; + } + + private ArgumentListTreeImpl arguments(PsiExpressionList list) { + var result = ArgumentListTreeImpl.emptyList(); + if (list != null && !list.getText().isEmpty()) { + result.complete(token(list, "("), last(list, ")")); + for (var argument : list.getExpressions()) { + result.add(expression(argument)); + if (tokens.at(end(argument)).text().equals(",")) { + result.separators().add(tokens.at(end(argument))); } - separators.add(createSyntaxToken(tokenIndex)); } } + return result; } - private List convertCatchClauses(TryStatement e) { - List catches = new ArrayList<>(); - for (Object o : e.catchClauses()) { - CatchClause c = (CatchClause) o; - catches.add(new CatchTreeImpl( - firstTokenIn(c, TerminalToken.TokenNamecatch), - firstTokenBefore(c.getException(), TerminalToken.TokenNameLPAREN), - convertVariable(c.getException()), - firstTokenAfter(c.getException(), TerminalToken.TokenNameRPAREN), - convertBlock(c.getBody()) - )); - } - return catches; - } - - private ExpressionStatementTreeImpl convertConstructorInvocation(ConstructorInvocation e) { - ArgumentListTreeImpl arguments = convertArguments( - e.arguments().isEmpty() ? lastTokenIn(e, TerminalToken.TokenNameLPAREN) : firstTokenBefore((ASTNode) e.arguments().get(0), TerminalToken.TokenNameLPAREN), - e.arguments(), - lastTokenIn(e, TerminalToken.TokenNameRPAREN) - ); - - IdentifierTreeImpl i = new IdentifierTreeImpl(e.arguments().isEmpty() - ? lastTokenIn(e, TerminalToken.TokenNamethis) - : firstTokenBefore((ASTNode) e.arguments().get(0), TerminalToken.TokenNamethis)); - MethodInvocationTreeImpl t = new MethodInvocationTreeImpl( - i, - convertTypeArguments(e.typeArguments()), - arguments - ); - setSymbol(t, e.resolveConstructorBinding()); - if (methodBinding(t) != null) { - setType(t, methodBinding(t).getDeclaringClass()); - setSymbol(t, excludeRecovery(methodBinding(t), arguments.size())); - } - setSymbol(i, methodBinding(t)); - usage(binding(i), i); - return new ExpressionStatementTreeImpl( - t, - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - - private ExpressionStatementTreeImpl convertSuperConstructorInvocation(SuperConstructorInvocation e) { - IdentifierTreeImpl i = new IdentifierTreeImpl(firstTokenIn(e, TerminalToken.TokenNamesuper)); - ExpressionTree methodSelect = i; - if (e.getExpression() != null) { - methodSelect = new MemberSelectExpressionTreeImpl( - convertExpression(e.getExpression()), - firstTokenAfter(e.getExpression(), TerminalToken.TokenNameDOT), - i - ); - } - - ArgumentListTreeImpl arguments = convertArguments( - firstTokenIn(e, TerminalToken.TokenNameLPAREN), - e.arguments(), - lastTokenIn(e, TerminalToken.TokenNameRPAREN) - ); - - MethodInvocationTreeImpl t = new MethodInvocationTreeImpl( - methodSelect, - convertTypeArguments(e.typeArguments()), - arguments - ); - setSymbol(t, e.resolveConstructorBinding()); - if (methodBinding(t) != null) { - setType(t, methodBinding(t).getDeclaringClass()); - setSymbol(t, excludeRecovery(methodBinding(t), arguments.size())); - } - setSymbol(i, methodBinding(t)); - usage(binding(i), i); - return new ExpressionStatementTreeImpl( - t, - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - - private YieldStatementTreeImpl convertYield(YieldStatement e) { - InternalSyntaxToken yieldKeyword = null; - if (!e.isImplicit()) { - yieldKeyword = firstTokenIn(e, TerminalToken.TokenNameRestrictedIdentifierYield); - } - return new YieldStatementTreeImpl( - yieldKeyword, - convertExpression(e.getExpression()), - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); - } - - private ExpressionTree convertExpression(Expression node) { - ExpressionTree t = createExpression(node); - setType(((AbstractTypedTree) t), node.resolveTypeBinding()); - return t; - } - - private ExpressionTree createExpression(Expression node) { - switch (node.getNodeType()) { - case ASTNode.SIMPLE_NAME: - return convertSimpleName((SimpleName) node); - case ASTNode.QUALIFIED_NAME: - return convertQualifiedName((QualifiedName) node); - case ASTNode.FIELD_ACCESS: - return convertFieldAccess((FieldAccess) node); - case ASTNode.SUPER_FIELD_ACCESS: - return convertFieldAccess((SuperFieldAccess) node); - case ASTNode.THIS_EXPRESSION: - return convertThisExpression((ThisExpression) node); - case ASTNode.ARRAY_ACCESS: - return convertArrayAccess((ArrayAccess) node); - case ASTNode.ARRAY_CREATION: - return convertArrayCreation((ArrayCreation) node); - case ASTNode.ARRAY_INITIALIZER: - return convertArrayInitializer((ArrayInitializer) node); - case ASTNode.ASSIGNMENT: - return convertAssignment((Assignment) node); - case ASTNode.CAST_EXPRESSION: - return convertTypeCastExpression((CastExpression) node); - case ASTNode.CLASS_INSTANCE_CREATION: - return convertClassInstanceCreation((ClassInstanceCreation) node); - case ASTNode.CONDITIONAL_EXPRESSION: - return convertConditionalExpression((ConditionalExpression) node); - case ASTNode.INFIX_EXPRESSION: - return convertInfixExpression((InfixExpression) node); - case ASTNode.METHOD_INVOCATION: - return convertMethodInvocation((MethodInvocation) node); - case ASTNode.SUPER_METHOD_INVOCATION: - return convertMethodInvocation((SuperMethodInvocation) node); - case ASTNode.PARENTHESIZED_EXPRESSION: - return convertParenthesizedExpression((ParenthesizedExpression) node); - case ASTNode.POSTFIX_EXPRESSION: - return convertPostfixExpression((PostfixExpression) node); - case ASTNode.PREFIX_EXPRESSION: - return convertPrefixExpression((PrefixExpression) node); - case ASTNode.INSTANCEOF_EXPRESSION: - return convertInstanceOf((InstanceofExpression) node); - case ASTNode.PATTERN_INSTANCEOF_EXPRESSION: - return convertInstanceOf((PatternInstanceofExpression) node); - case ASTNode.LAMBDA_EXPRESSION: - return convertLambdaExpression((LambdaExpression) node); - case ASTNode.CREATION_REFERENCE: - return convertMethodReference((CreationReference) node); - case ASTNode.EXPRESSION_METHOD_REFERENCE: - return convertMethodReference((ExpressionMethodReference) node); - case ASTNode.TYPE_METHOD_REFERENCE: - return convertMethodReference((TypeMethodReference) node); - case ASTNode.SUPER_METHOD_REFERENCE: - return convertMethodReference((SuperMethodReference) node); - case ASTNode.SWITCH_EXPRESSION: - return convertSwitchExpression((SwitchExpression) node); - case ASTNode.TYPE_LITERAL: - return convertTypeLiteral((TypeLiteral) node); - case ASTNode.NULL_LITERAL: - return convertLiteral((NullLiteral) node); - case ASTNode.NUMBER_LITERAL: - return convertLiteral((NumberLiteral) node); - case ASTNode.CHARACTER_LITERAL: - return convertLiteral((CharacterLiteral) node); - case ASTNode.BOOLEAN_LITERAL: - return convertLiteral((BooleanLiteral) node); - case ASTNode.STRING_LITERAL: - return convertLiteral((StringLiteral) node); - case ASTNode.TEXT_BLOCK: - return convertTextBlock((TextBlock) node); - case ASTNode.NORMAL_ANNOTATION, - ASTNode.MARKER_ANNOTATION, - ASTNode.SINGLE_MEMBER_ANNOTATION: - return convertAnnotation((Annotation) node); - default: - throw new IllegalStateException(ASTNode.nodeClassForType(node.getNodeType()).toString()); - } - } - - private IdentifierTreeImpl convertSimpleName(SimpleName e) { - IdentifierTreeImpl t = createSimpleName(e); - usage(binding(t), t); - return t; - } - - private MemberSelectExpressionTreeImpl convertQualifiedName(QualifiedName e) { - IdentifierTreeImpl rhs = createSimpleName(e.getName()); - usage(binding(rhs), rhs); - return new MemberSelectExpressionTreeImpl( - convertExpression(e.getQualifier()), - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), - rhs - ); - } - - private MemberSelectExpressionTreeImpl convertFieldAccess(FieldAccess e) { - IdentifierTreeImpl rhs = createSimpleName(e.getName()); - usage(binding(rhs), rhs); - return new MemberSelectExpressionTreeImpl( - convertExpression(e.getExpression()), - firstTokenAfter(e.getExpression(), TerminalToken.TokenNameDOT), - rhs - ); - } - - private MemberSelectExpressionTreeImpl convertFieldAccess(SuperFieldAccess e) { - IdentifierTreeImpl rhs = createSimpleName(e.getName()); - usage(binding(rhs), rhs); - if (e.getQualifier() == null) { - // super.name - return new MemberSelectExpressionTreeImpl( - unqualifiedKeywordSuper(e), - firstTokenIn(e, TerminalToken.TokenNameDOT), - rhs - ); - } - // qualifier.super.name - AbstractTypedTree qualifier = (AbstractTypedTree) convertExpression(e.getQualifier()); - KeywordSuper keywordSuper = keywordSuper(firstTokenAfter(e.getQualifier(), TerminalToken.TokenNamesuper), null); - MemberSelectExpressionTreeImpl qualifiedSuper = new MemberSelectExpressionTreeImpl( - (ExpressionTree) qualifier, - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), - keywordSuper - ); - if (typeBinding(qualifier) != null) { - setType(keywordSuper, typeBinding(qualifier)); - setType(qualifiedSuper, typeBinding(keywordSuper).getSuperclass()); - } - return new MemberSelectExpressionTreeImpl( - qualifiedSuper, - firstTokenBefore(e.getName(), TerminalToken.TokenNameDOT), - rhs - ); - } - - private ExpressionTree convertThisExpression(ThisExpression e) { - if (e.getQualifier() == null) { - return keywordThis(firstTokenIn(e, TerminalToken.TokenNamethis), null); - } - KeywordThis keywordThis = keywordThis( - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNamethis), - e.resolveTypeBinding() - ); - return new MemberSelectExpressionTreeImpl( - convertExpression(e.getQualifier()), - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), - keywordThis - ); - } - - private MemberSelectExpressionTreeImpl convertTypeLiteral(TypeLiteral e) { - return new MemberSelectExpressionTreeImpl( - (ExpressionTree) convertType(e.getType()), - lastTokenIn(e, TerminalToken.TokenNameDOT), - new IdentifierTreeImpl( - lastTokenIn(e, TerminalToken.TokenNameclass) - ) - ); - } - - private ArrayAccessExpressionTreeImpl convertArrayAccess(ArrayAccess e) { - Expression index = e.getIndex(); - return new ArrayAccessExpressionTreeImpl( - convertExpression(e.getArray()), - new ArrayDimensionTreeImpl( - firstTokenBefore(index, TerminalToken.TokenNameLBRACKET), - convertExpression(index), - firstTokenAfter(index, TerminalToken.TokenNameRBRACKET) - ) - ); - } - - private NewArrayTreeImpl convertArrayCreation(ArrayCreation e) { - List dimensions = ((List) e.dimensions()).stream() - .map(Expression.class::cast) - .map(dimension -> new ArrayDimensionTreeImpl( - firstTokenBefore(dimension, TerminalToken.TokenNameLBRACKET), - convertExpression(dimension), - firstTokenAfter(dimension, TerminalToken.TokenNameRBRACKET) - )) - .collect(Collectors.toCollection(ArrayList::new)); - InitializerListTreeImpl initializers = InitializerListTreeImpl.emptyList(); - if (e.getInitializer() != null) { - assert dimensions.isEmpty(); - - TypeTree type = convertType(e.getType()); - while (type.is(Tree.Kind.ARRAY_TYPE)) { - ArrayTypeTree arrayType = (ArrayTypeTree) type; - ArrayDimensionTreeImpl dimension = new ArrayDimensionTreeImpl( - arrayType.openBracketToken(), - null, - arrayType.closeBracketToken() - ).completeAnnotations(arrayType.annotations()); - dimensions.add(/* TODO suboptimal */ 0, dimension); - type = arrayType.type(); - } + private TypeArgumentListTreeImpl typeArguments(PsiReferenceParameterList list) { + return list == null || list.getText().isEmpty() ? null : new TypeCursor(start(list), end(list)).arguments(false); + } - return ((NewArrayTreeImpl) convertExpression(e.getInitializer())) - .completeWithNewKeyword(firstTokenIn(e, TerminalToken.TokenNamenew)) - .complete(type) - .completeDimensions(dimensions); - } - TypeTree type = convertType(e.getType()); - int index = dimensions.size() - 1; - while (type.is(Tree.Kind.ARRAY_TYPE)) { - if (!type.annotations().isEmpty()) { - ((ArrayDimensionTreeImpl) dimensions.get(index)) - .completeAnnotations(type.annotations()); + private ExpressionTree cast(PsiTypeCastExpression cast) { + var source = cast.getCastType(); + var cursor = new TypeCursor(start(source), end(source)); + var first = cursor.type(); + if (cursor.more() && cursor.peek().equals("&")) { + var ampersand = cursor.take(); + var bounds = QualifiedIdentifierListTreeImpl.emptyList(); + while (cursor.more()) { + bounds.add(cursor.type()); + if (cursor.more()) { + bounds.separators().add(cursor.take("&")); + } } - index--; - type = ((ArrayTypeTree) type).type(); + return new TypeCastExpressionTreeImpl(token(cast, "("), first, ampersand, bounds, + tokens.find(end(source), start(cast.getOperand()), ")", false), expression(cast.getOperand())); } + return new TypeCastExpressionTreeImpl(token(cast, "("), remember(source, first), tokens.find(end(source), start(cast.getOperand()), ")", false), expression(cast.getOperand())); + } - return new NewArrayTreeImpl(dimensions, initializers) - .complete(type) - .completeWithNewKeyword(firstTokenIn(e, TerminalToken.TokenNamenew)); + private ExpressionTree newExpression(PsiNewExpression creation) { + if (creation.isArrayCreation()) { + return newArray(creation); + } + var result = new NewClassTreeImpl(typeReference(creation.getClassOrAnonymousClassReference()), arguments(creation.getArgumentList()), + creation.getAnonymousClass() == null ? null : classTree(creation.getAnonymousClass())) + .completeWithNewKeyword(tokens.find(creation.getQualifier() == null ? start(creation) : end(creation.getQualifier()), + start(creation.getClassOrAnonymousClassReference()), "new", false)).completeWithTypeArguments(typeArguments(creation.getTypeArgumentList())); + if (creation.getQualifier() != null) { + result.completeWithEnclosingExpression(expression(creation.getQualifier())); + result.completeWithDotToken(tokens.find(end(creation.getQualifier()), start(creation.getClassOrAnonymousClassReference()), ".", false)); + } + return result; } - private NewArrayTreeImpl convertArrayInitializer(ArrayInitializer e) { - InitializerListTreeImpl initializers = InitializerListTreeImpl.emptyList(); - for (int i = 0; i < e.expressions().size(); i++) { - Expression o = (Expression) e.expressions().get(i); - initializers.add(convertExpression(o)); - final int commaTokenIndex = firstTokenIndexAfter(o); - if (tokenManager.get(commaTokenIndex).tokenType == TerminalToken.TokenNameCOMMA) { - initializers.separators().add(firstTokenAfter(o, TerminalToken.TokenNameCOMMA)); + private NewArrayTreeImpl arrayInitializer(PsiElement element, PsiElement[] values) { + var initializers = InitializerListTreeImpl.emptyList(); + for (var value : values) { + initializers.add(expression(value)); + if (tokens.at(end(value)).text().equals(",")) { + initializers.separators().add(tokens.at(end(value))); } } - return new NewArrayTreeImpl(Collections.emptyList(),initializers) - .completeWithCurlyBraces( - firstTokenIn(e, TerminalToken.TokenNameLBRACE), - lastTokenIn(e, TerminalToken.TokenNameRBRACE) - ); - } - - private AssignmentExpressionTreeImpl convertAssignment(Assignment e) { - Op op = operators.get(e.getOperator()); - return new AssignmentExpressionTreeImpl( - op.kind, - convertExpression(e.getLeftHandSide()), - firstTokenAfter(e.getLeftHandSide(), op.tokenType), - convertExpression(e.getRightHandSide()) - ); - } - - private TypeCastExpressionTreeImpl convertTypeCastExpression(CastExpression e) { - Type type = e.getType(); - if (type.getNodeType() == ASTNode.INTERSECTION_TYPE) { - List intersectionTypes = ((IntersectionType) type).types(); - QualifiedIdentifierListTreeImpl bounds = QualifiedIdentifierListTreeImpl.emptyList(); - for (int i = 1; i < intersectionTypes.size(); i++) { - Type o = (Type) intersectionTypes.get(i); - bounds.add(convertType(o)); - if (i < intersectionTypes.size() - 1) { - bounds.separators().add(firstTokenAfter(o, TerminalToken.TokenNameAND)); - } - } - return new TypeCastExpressionTreeImpl( - firstTokenBefore(type, TerminalToken.TokenNameLPAREN), - convertType((Type) intersectionTypes.get(0)), - firstTokenAfter((Type) intersectionTypes.get(0), TerminalToken.TokenNameAND), - bounds, - firstTokenAfter(type, TerminalToken.TokenNameRPAREN), - convertExpression(e.getExpression()) - ); - } - return new TypeCastExpressionTreeImpl( - firstTokenBefore(type, TerminalToken.TokenNameLPAREN), - convertType(type), - firstTokenAfter(type, TerminalToken.TokenNameRPAREN), - convertExpression(e.getExpression()) - ); - } - - private NewClassTreeImpl convertClassInstanceCreation(ClassInstanceCreation e) { - ArgumentListTreeImpl arguments = convertArguments( - firstTokenAfter(e.getType(), TerminalToken.TokenNameLPAREN), - e.arguments(), - firstTokenAfter(e.arguments().isEmpty() ? e.getType() : (ASTNode) e.arguments().get(e.arguments().size() - 1), TerminalToken.TokenNameRPAREN) - ); - - ClassTreeImpl classBody = null; - if (e.getAnonymousClassDeclaration() != null) { - List members = new ArrayList<>(); - for (Object o : e.getAnonymousClassDeclaration().bodyDeclarations()) { - processBodyDeclaration((BodyDeclaration) o, members); + return new NewArrayTreeImpl(List.of(), initializers).completeWithCurlyBraces(token(element, "{"), last(element, "}")); + } + + private NewArrayTreeImpl newArray(PsiNewExpression creation) { + var newKeyword = token(creation, "new"); + int offset = offset(newKeyword) + newKeyword.text().length(); + var cursor = new TypeCursor(offset, end(creation)); + cursor.includeDimensions = false; + var component = cursor.type(); + List dimensions = new ArrayList<>(); + var expressions = Arrays.asList(creation.getArrayDimensions()); + while (cursor.more() && (cursor.peek().equals("[") || cursor.peek().equals("@"))) { + var annotations = cursor.annotations(); + var left = cursor.take("["); + ExpressionTree expression = null; + if (!cursor.peek().equals("]")) { + int start = cursor.offset; + var dimension = expressions.stream().filter(e -> start(e) == start).findFirst().orElseThrow(); + expression = expression(dimension); + cursor.offset = end(dimension); } - classBody = new ClassTreeImpl( - Tree.Kind.CLASS, - firstTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameLBRACE), - members, - lastTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameRBRACE) - ); - setType(classBody, e.getAnonymousClassDeclaration().resolveBinding()); - declaration(typeBinding(classBody), classBody); - } - - NewClassTreeImpl t = new NewClassTreeImpl( - convertType(e.getType()), - arguments, - classBody - ).completeWithNewKeyword( - e.getExpression() == null ? firstTokenIn(e, TerminalToken.TokenNamenew) : firstTokenAfter(e.getExpression(), TerminalToken.TokenNamenew) - ).completeWithTypeArguments( - convertTypeArguments(e.typeArguments()) - ); - if (e.getExpression() != null) { - t.completeWithEnclosingExpression(convertExpression(e.getExpression())); - t.completeWithDotToken(firstTokenAfter(e.getExpression(), TerminalToken.TokenNameDOT)); - } - - IdentifierTreeImpl i = (IdentifierTreeImpl) t.getConstructorIdentifier(); - int nbArguments = arguments.size(); - if (e.getAnonymousClassDeclaration() == null) { - setSymbol(i, excludeRecovery(e.resolveConstructorBinding(), nbArguments)); - } else { - setSymbol(i, excludeRecovery(findConstructorForAnonymousClass(e.getAST(), typeBinding(i), e.resolveConstructorBinding()), nbArguments)); - } - usage(binding(i), i); - - return t; - } - - private ConditionalExpressionTreeImpl convertConditionalExpression(ConditionalExpression e) { - return new ConditionalExpressionTreeImpl( - convertExpression(e.getExpression()), - firstTokenAfter(e.getExpression(), TerminalToken.TokenNameQUESTION), - convertExpression(e.getThenExpression()), - firstTokenAfter(e.getThenExpression(), TerminalToken.TokenNameCOLON), - convertExpression(e.getElseExpression()) - ); - } - - private BinaryExpressionTreeImpl convertInfixExpression(InfixExpression e) { - Op op = operators.get(e.getOperator()); - BinaryExpressionTreeImpl t = new BinaryExpressionTreeImpl( - op.kind, - convertExpression(e.getLeftOperand()), - firstTokenAfter(e.getLeftOperand(), op.tokenType), - convertExpression(e.getRightOperand()) - ); - for (Object o : e.extendedOperands()) { - Expression e2 = (Expression) o; - setType(t, e.resolveTypeBinding()); - t = new BinaryExpressionTreeImpl( - op.kind, - t, - firstTokenBefore(e2, op.tokenType), - convertExpression(e2) - ); - } - return t; - } - - private MethodInvocationTreeImpl convertMethodInvocation(MethodInvocation e) { - ArgumentListTreeImpl arguments = convertArguments( - firstTokenAfter(e.getName(), TerminalToken.TokenNameLPAREN), - e.arguments(), - lastTokenIn(e, TerminalToken.TokenNameRPAREN) - ); - - IdentifierTreeImpl rhs = createSimpleName(e.getName()); - ExpressionTree memberSelect; - if (e.getExpression() == null) { - memberSelect = rhs; - } else { - memberSelect = new MemberSelectExpressionTreeImpl( - convertExpression(e.getExpression()), - firstTokenAfter(e.getExpression(), TerminalToken.TokenNameDOT), - rhs - ); - } - MethodInvocationTreeImpl t = new MethodInvocationTreeImpl( - memberSelect, - convertTypeArguments(e.typeArguments()), - arguments - ); - setSymbol(t, excludeRecovery(e.resolveMethodBinding(), arguments.size())); - setSymbol(rhs, methodBinding(t)); - usage(binding(rhs), rhs); - return t; - } - - private MethodInvocationTreeImpl convertMethodInvocation(SuperMethodInvocation e) { - ArgumentListTreeImpl arguments = convertArguments( - firstTokenIn(e, TerminalToken.TokenNameLPAREN), - e.arguments(), - lastTokenIn(e, TerminalToken.TokenNameRPAREN) - ); - - IdentifierTreeImpl rhs = createSimpleName(e.getName()); - - ExpressionTree outermostSelect; - if (e.getQualifier() == null) { - outermostSelect = new MemberSelectExpressionTreeImpl( - unqualifiedKeywordSuper(e), - firstTokenIn(e, TerminalToken.TokenNameDOT), - rhs - ); - } else { - final int firstDotTokenIndex = tokenManager.firstIndexAfter(e.getQualifier(), TerminalToken.TokenNameDOT); - AbstractTypedTree qualifier = (AbstractTypedTree) convertExpression(e.getQualifier()); - KeywordSuper keywordSuper = keywordSuper(firstTokenAfter(e.getQualifier(), TerminalToken.TokenNamesuper), null); - MemberSelectExpressionTreeImpl qualifiedSuper = new MemberSelectExpressionTreeImpl( - (ExpressionTree) qualifier, - createSyntaxToken(firstDotTokenIndex), - keywordSuper - ); - if (typeBinding(qualifier) != null) { - setType(keywordSuper, typeBinding(qualifier)); - setType(qualifiedSuper, typeBinding(keywordSuper).getSuperclass()); + var dimension = new ArrayDimensionTreeImpl(left, expression, cursor.take("]")).completeAnnotations(annotations); + if (expression != null || creation.getArrayInitializer() != null) { + dimensions.add(dimension); } - outermostSelect = new MemberSelectExpressionTreeImpl( - qualifiedSuper, - createSyntaxToken(nextTokenIndex(firstDotTokenIndex, TerminalToken.TokenNameDOT)), - rhs - ); } - - MethodInvocationTreeImpl t = new MethodInvocationTreeImpl( - outermostSelect, - null, - arguments - ); - setSymbol(t, excludeRecovery(e.resolveMethodBinding(), arguments.size())); - setSymbol(rhs, methodBinding(t)); - usage(binding(rhs), rhs); - return t; - } - - private ParenthesizedTreeImpl convertParenthesizedExpression(ParenthesizedExpression e) { - return new ParenthesizedTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameLPAREN), - convertExpression(e.getExpression()), - firstTokenAfter(e.getExpression(), TerminalToken.TokenNameRPAREN) - ); - } - - private InternalPostfixUnaryExpression convertPostfixExpression(PostfixExpression e) { - Op op = operators.get(e.getOperator()); - return new InternalPostfixUnaryExpression( - op.kind, - convertExpression(e.getOperand()), - firstTokenAfter(e.getOperand(), op.tokenType) - ); + var result = creation.getArrayInitializer() == null ? new NewArrayTreeImpl(dimensions, InitializerListTreeImpl.emptyList()) + : arrayInitializer(creation.getArrayInitializer(), creation.getArrayInitializer().getInitializers()).completeDimensions(dimensions); + return result.complete(component).completeWithNewKeyword(newKeyword); } - private InternalPrefixUnaryExpression convertPrefixExpression(PrefixExpression e) { - Op op = operators.get(e.getOperator()); - return new InternalPrefixUnaryExpression( - op.kind, - firstTokenIn(e, op.tokenType), - convertExpression(e.getOperand()) - ); + private LambdaExpressionTreeImpl lambda(PsiLambdaExpression lambda) { + List parameters = new ArrayList<>(); + for (var parameter : lambda.getParameterList().getParameters()) { + var result = variable(parameter); + if (tokens.at(end(parameter)).text().equals(",")) { + result.setEndToken(tokens.at(end(parameter))); + } + parameters.add(result); + } + var body = lambda.getBody(); + boolean parentheses = lambda.getParameterList().getText().startsWith("("); + return new LambdaExpressionTreeImpl(parentheses ? token(lambda.getParameterList(), "(") : null, parameters, + parentheses ? last(lambda.getParameterList(), ")") : null, tokens.find(end(lambda.getParameterList()), start(body), "->", false), + body instanceof PsiCodeBlock block ? block(block) : expression(body)); } - private InstanceOfTreeImpl convertInstanceOf(InstanceofExpression e) { - Expression leftOperand = e.getLeftOperand(); - InternalSyntaxToken instanceofToken = firstTokenAfter(leftOperand, TerminalToken.TokenNameinstanceof); - return new InstanceOfTreeImpl(convertExpression(leftOperand), instanceofToken, convertType(e.getRightOperand())); + private MethodReferenceTreeImpl methodReference(PsiMethodReferenceExpression reference) { + var qualifier = reference.getQualifierExpression(); + var type = reference.getQualifierType(); + var result = new MethodReferenceTreeImpl(qualifier == null ? type(type) : expression(qualifier), token(reference, "::")); + result.complete(typeArguments(reference.getParameterList()), identifier(reference.getReferenceNameElement())); + return result; } - private InstanceOfTreeImpl convertInstanceOf(PatternInstanceofExpression e) { - Expression leftOperand = e.getLeftOperand(); - InternalSyntaxToken instanceofToken = firstTokenAfter(leftOperand, TerminalToken.TokenNameinstanceof); - return new InstanceOfTreeImpl(convertExpression(leftOperand), instanceofToken, convertPattern(e.getPattern())); + private PatternTree pattern(PsiPattern pattern) { + PatternTree result; + if (pattern instanceof PsiTypeTestPattern type) { + result = new TypePatternTreeImpl(variable(type.getPatternVariable()), SemanticValues.UNKNOWN_TYPE); + } else if (pattern instanceof PsiDeconstructionPattern record) { + var nested = Arrays.stream(record.getDeconstructionList().getDeconstructionComponents()).map(this::pattern).toList(); + result = new RecordPatternTreeImpl(type(record.getTypeElement()), token(record.getDeconstructionList(), "("), nested, last(record.getDeconstructionList(), ")")); + } else if (pattern instanceof PsiUnnamedPattern unnamed) { + result = new TypePatternTreeImpl(new VariableTreeImpl(new IdentifierTreeImpl(token(unnamed, "_"), true)), SemanticValues.UNKNOWN_TYPE); + } else { + throw unsupported(pattern); + } + return remember(pattern, result); } - private LambdaExpressionTreeImpl convertLambdaExpression(LambdaExpression e) { - List parameters = new ArrayList<>(); - for (int i = 0; i < e.parameters().size(); i++) { - VariableDeclaration o = (VariableDeclaration) e.parameters().get(i); - VariableTreeImpl t; - if (o.getNodeType() == ASTNode.VARIABLE_DECLARATION_FRAGMENT) { - t = new VariableTreeImpl(createSimpleName(o.getName())); - IVariableBinding variableBinding = o.resolveBinding(); - if (variableBinding != null) { - setSymbol(t, variableBinding); - setType(((InferedTypeTree) t.type()), variableBinding.getType()); - declaration(variableBinding(t), t); + private BlockTreeImpl block(PsiCodeBlock block) { + List statements = new ArrayList<>(); + for (var statement : block.getStatements()) { + addStatement(statement, statements, true); + } + return remember(block, new BlockTreeImpl(exact(block.getLBrace()), statements, exact(block.getRBrace()))); + } + + private void addStatement(PsiStatement statement, List target, boolean semicolon) { + if (statement instanceof PsiDeclarationStatement declaration) { + var declarations = declaration.getDeclaredElements(); + for (int i = 0; i < declarations.length; i++) { + if (declarations[i] instanceof PsiVariable variable) { + var tree = variable(variable); + if (i < declarations.length - 1) { + tree.setEndToken(tokens.find(end(variable), end(declaration), ",", false)); + } else if (semicolon) { + tree.setEndToken(last(declaration, ";")); + } + target.add(tree); + } else if (declarations[i] instanceof PsiClass cls) { + target.add(classTree(cls)); + } else { + throw unsupported(declarations[i]); } - } else { - t = convertVariable((SingleVariableDeclaration) o); } - parameters.add(t); - if (i < e.parameters().size() - 1) { - t.setEndToken(firstTokenAfter(o, TerminalToken.TokenNameCOMMA)); + } else if (!semicolon && statement instanceof PsiEmptyStatement) { + return; + } else if (!semicolon && statement instanceof PsiExpressionStatement expression) { + target.add(new ExpressionStatementTreeImpl(expression(expression.getExpression()), null)); + } else if (statement instanceof PsiExpressionListStatement expressions) { + for (var expression : expressions.getExpressionList().getExpressions()) { + target.add(new ExpressionStatementTreeImpl(expression(expression), null)); } + } else { + target.add(statement(statement)); + } + } + + private StatementTree statement(PsiStatement statement) { + StatementTree result = switch (statement) { + case PsiBlockStatement block -> block(block.getCodeBlock()); + case PsiEmptyStatement empty -> new EmptyStatementTreeImpl(token(empty, ";")); + case PsiExpressionStatement expression -> new ExpressionStatementTreeImpl(expression(expression.getExpression()), last(expression, ";")); + case PsiReturnStatement returned -> new ReturnStatementTreeImpl(token(returned, "return"), returned.getReturnValue() == null ? null : expression(returned.getReturnValue()), last(returned, ";")); + case PsiThrowStatement thrown -> new ThrowStatementTreeImpl(token(thrown, "throw"), expression(thrown.getException()), last(thrown, ";")); + case PsiIfStatement branch -> new IfStatementTreeImpl(token(branch, "if"), token(branch, "("), expression(branch.getCondition()), + tokens.find(end(branch.getCondition()), start(branch.getThenBranch()), ")", false), statement(branch.getThenBranch()), + branch.getElseBranch() == null ? null : tokens.find(end(branch.getThenBranch()), start(branch.getElseBranch()), "else", false), + branch.getElseBranch() == null ? null : statement(branch.getElseBranch())); + case PsiWhileStatement loop -> new WhileStatementTreeImpl(token(loop, "while"), token(loop, "("), expression(loop.getCondition()), + tokens.find(end(loop.getCondition()), start(loop.getBody()), ")", false), statement(loop.getBody())); + case PsiDoWhileStatement loop -> new DoWhileStatementTreeImpl(token(loop, "do"), statement(loop.getBody()), + tokens.find(end(loop.getBody()), start(loop.getCondition()), "while", false), tokens.find(end(loop.getBody()), start(loop.getCondition()), "(", false), + expression(loop.getCondition()), last(loop, ")"), last(loop, ";")); + case PsiForStatement loop -> forStatement(loop); + case PsiForeachStatement loop -> new ForEachStatementImpl(token(loop, "for"), token(loop, "("), variable(loop.getIterationParameter()), + tokens.find(end(loop.getIterationParameter()), start(loop.getIteratedValue()), ":", false), expression(loop.getIteratedValue()), + tokens.find(end(loop.getIteratedValue()), start(loop.getBody()), ")", false), statement(loop.getBody())); + case PsiBreakStatement broken -> new BreakStatementTreeImpl(token(broken, "break"), labelReference(broken.getLabelIdentifier()), last(broken, ";")); + case PsiContinueStatement continued -> new ContinueStatementTreeImpl(token(continued, "continue"), labelReference(continued.getLabelIdentifier()), last(continued, ";")); + case PsiLabeledStatement labeled -> labeled(labeled); + case PsiSynchronizedStatement synchronizedStatement -> new SynchronizedStatementTreeImpl(token(synchronizedStatement, "synchronized"), token(synchronizedStatement, "("), + expression(synchronizedStatement.getLockExpression()), tokens.find(end(synchronizedStatement.getLockExpression()), start(synchronizedStatement.getBody()), ")", false), block(synchronizedStatement.getBody())); + case PsiAssertStatement assertion -> assertion(assertion); + case PsiTryStatement tried -> tryStatement(tried); + case PsiSwitchStatement switched -> switchStatement(switched); + case PsiYieldStatement yielded -> new YieldStatementTreeImpl(token(yielded, "yield"), expression(yielded.getExpression()), last(yielded, ";")); + case PsiDeclarationStatement declaration -> singleDeclaration(declaration); + default -> throw unsupported(statement); + }; + return remember(statement, result); + } + + private StatementTree singleDeclaration(PsiDeclarationStatement declaration) { + List result = new ArrayList<>(); + addStatement(declaration, result, true); + if (result.size() != 1) { + throw unsupported(declaration); } - ASTNode body = e.getBody(); - var tree = new LambdaExpressionTreeImpl( - e.hasParentheses() ? firstTokenIn(e, TerminalToken.TokenNameLPAREN) : null, - parameters, - e.hasParentheses() ? firstTokenBefore(body, TerminalToken.TokenNameRPAREN) : null, - firstTokenBefore(body, TerminalToken.TokenNameARROW), - body.getNodeType() == ASTNode.BLOCK ? convertBlock((Block) body) : convertExpression((Expression) body) - ); - setSymbol(tree, e.resolveMethodBinding()); - return tree; + return result.getFirst(); } - private MethodReferenceTreeImpl convertMethodReference(CreationReference e) { - MethodReferenceTreeImpl t = new MethodReferenceTreeImpl( - convertType(e.getType()), - lastTokenIn(e, TerminalToken.TokenNameCOLON_COLON) - ); - IdentifierTreeImpl i = new IdentifierTreeImpl(lastTokenIn(e, TerminalToken.TokenNamenew)); - setSymbol(i, e.resolveMethodBinding()); - usage(binding(i), i); - t.complete(convertTypeArguments(e.typeArguments()), i); - return t; - } - - private MethodReferenceTreeImpl convertMethodReference(ExpressionMethodReference e) { - MethodReferenceTreeImpl t = new MethodReferenceTreeImpl( - convertExpression(e.getExpression()), - firstTokenAfter(e.getExpression(), TerminalToken.TokenNameCOLON_COLON) - ); - IdentifierTreeImpl i = createSimpleName(e.getName()); - usage(binding(i), i); - t.complete(convertTypeArguments(e.typeArguments()), i); - return t; - } - - private MethodReferenceTreeImpl convertMethodReference(TypeMethodReference e) { - MethodReferenceTreeImpl t = new MethodReferenceTreeImpl( - convertType(e.getType()), - firstTokenAfter(e.getType(), TerminalToken.TokenNameCOLON_COLON) - ); - IdentifierTreeImpl i = createSimpleName(e.getName()); - usage(binding(i), i); - t.complete(convertTypeArguments(e.typeArguments()), i); - return t; - } - - private MethodReferenceTreeImpl convertMethodReference(SuperMethodReference e) { - MethodReferenceTreeImpl t; - if (e.getQualifier() != null) { - t = new MethodReferenceTreeImpl( - new MemberSelectExpressionTreeImpl( - convertExpression(e.getQualifier()), - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), - unqualifiedKeywordSuper(e) - ), - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameCOLON_COLON) - ); - } else { - t = new MethodReferenceTreeImpl( - unqualifiedKeywordSuper(e), - firstTokenIn(e, TerminalToken.TokenNameCOLON_COLON) - ); - } - IdentifierTreeImpl i = createSimpleName(e.getName()); - usage(binding(i), i); - t.complete(convertTypeArguments(e.typeArguments()), i); - return t; - } - - private SwitchExpressionTreeImpl convertSwitchExpression(SwitchExpression e) { - Expression expr = e.getExpression(); - return new SwitchExpressionTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameswitch), - firstTokenIn(e, TerminalToken.TokenNameLPAREN), - convertExpression(expr), - firstTokenAfter(expr, TerminalToken.TokenNameRPAREN), - firstTokenAfter(expr, TerminalToken.TokenNameLBRACE), - convertSwitchStatements(e.statements()), - lastTokenIn(e, TerminalToken.TokenNameRBRACE) - ); - } - - private LiteralTreeImpl convertLiteral(NullLiteral e) { - return new LiteralTreeImpl(Tree.Kind.NULL_LITERAL, firstTokenIn(e, TerminalToken.TokenNamenull)); - } - - private ExpressionTree convertLiteral(NumberLiteral e) { - int tokenIndex = tokenManager.findIndex(e.getStartPosition(), ANY_TOKEN, true); - TerminalToken tokenType = tokenManager.get(tokenIndex).tokenType; - boolean unaryMinus = tokenType == TerminalToken.TokenNameMINUS; - if (unaryMinus) { - tokenIndex++; - tokenType = tokenManager.get(tokenIndex).tokenType; - } - ExpressionTree result; - switch (tokenType) { - case TokenNameIntegerLiteral: - result = new LiteralTreeImpl(Tree.Kind.INT_LITERAL, createSyntaxToken(tokenIndex)); - break; - case TokenNameLongLiteral: - result = new LiteralTreeImpl(Tree.Kind.LONG_LITERAL, createSyntaxToken(tokenIndex)); - break; - case TokenNameFloatingPointLiteral: - result = new LiteralTreeImpl(Tree.Kind.FLOAT_LITERAL, createSyntaxToken(tokenIndex)); - break; - case TokenNameDoubleLiteral: - result = new LiteralTreeImpl(Tree.Kind.DOUBLE_LITERAL, createSyntaxToken(tokenIndex)); - break; - default: - throw new IllegalStateException(); + private ForStatementTreeImpl forStatement(PsiForStatement loop) { + var initializer = StatementListTreeImpl.emptyList(); + var update = StatementListTreeImpl.emptyList(); + if (loop.getInitialization() != null) { + addStatement(loop.getInitialization(), initializer, false); + expressionSeparators(loop.getInitialization(), initializer); } - setType(((LiteralTreeImpl) result), e.resolveTypeBinding()); - if (unaryMinus) { - return new InternalPrefixUnaryExpression(Tree.Kind.UNARY_MINUS, createSyntaxToken(tokenIndex - 1), result); + if (loop.getUpdate() != null) { + addStatement(loop.getUpdate(), update, false); + expressionSeparators(loop.getUpdate(), update); } - return result; + var first = loop.getInitialization() == null ? token(loop, ";") : last(loop.getInitialization(), ";"); + var second = tokens.find(loop.getCondition() == null ? offset(first) + 1 : end(loop.getCondition()), end(loop), ";", false); + return new ForStatementTreeImpl(token(loop, "for"), token(loop, "("), initializer, first, + loop.getCondition() == null ? null : expression(loop.getCondition()), second, update, + tokens.find(loop.getCondition() == null ? start(loop) : end(loop.getCondition()), start(loop.getBody()), ")", true), statement(loop.getBody())); } - private LiteralTreeImpl convertLiteral(CharacterLiteral e) { - return new LiteralTreeImpl(Tree.Kind.CHAR_LITERAL, firstTokenIn(e, TerminalToken.TokenNameCharacterLiteral)); + private void expressionSeparators(PsiStatement statement, StatementListTreeImpl list) { + if (statement instanceof PsiExpressionListStatement expressions) { + for (var expression : expressions.getExpressionList().getExpressions()) { + if (tokens.at(end(expression)).text().equals(",")) { + list.separators().add(tokens.at(end(expression))); + } + } + } } - private LiteralTreeImpl convertLiteral(BooleanLiteral e) { - InternalSyntaxToken value = firstTokenIn(e, e.booleanValue() ? TerminalToken.TokenNametrue : TerminalToken.TokenNamefalse); - return new LiteralTreeImpl(Tree.Kind.BOOLEAN_LITERAL, value); + private int offset(SyntaxToken token) { + return tokens.lexemes().stream().filter(t -> t.token() == token).findFirst().orElseThrow().start(); } - private LiteralTreeImpl convertLiteral(StringLiteral e) { - return new LiteralTreeImpl(Tree.Kind.STRING_LITERAL, firstTokenIn(e, TerminalToken.TokenNameStringLiteral)); - } + private final java.util.Deque labels = new java.util.ArrayDeque<>(); - private LiteralTreeImpl convertTextBlock(TextBlock e) { - return new LiteralTreeImpl(Tree.Kind.TEXT_BLOCK, firstTokenIn(e, TerminalToken.TokenNameTextBlock)); + private LabeledStatementTreeImpl labeled(PsiLabeledStatement labeled) { + var name = identifier(labeled.getLabelIdentifier()); + var symbol = new JLabelSymbol(name.name()); + labels.push(symbol); + var result = new LabeledStatementTreeImpl(name, token(labeled, ":"), statement(labeled.getStatement())); + labels.pop(); + symbol.declaration = result; + result.labelSymbol = symbol; + return result; } - private AnnotationTreeImpl convertAnnotation(Annotation e) { - ArgumentListTreeImpl arguments = ArgumentListTreeImpl.emptyList(); - if (e.getNodeType() == ASTNode.SINGLE_MEMBER_ANNOTATION) { - arguments.add(convertExpression(((SingleMemberAnnotation) e).getValue())); - arguments.complete( - firstTokenIn(e, TerminalToken.TokenNameLPAREN), - lastTokenIn(e, TerminalToken.TokenNameRPAREN) - ); - } else if (e.getNodeType() == ASTNode.NORMAL_ANNOTATION) { - for (int i = 0; i < ((NormalAnnotation) e).values().size(); i++) { - MemberValuePair o = (MemberValuePair) ((NormalAnnotation) e).values().get(i); - arguments.add(new AssignmentExpressionTreeImpl( - Tree.Kind.ASSIGNMENT, - createSimpleName(o.getName()), - firstTokenAfter(o.getName(), TerminalToken.TokenNameEQUAL), - convertExpression(o.getValue()) - )); - if (i < ((NormalAnnotation) e).values().size() - 1) { - arguments.separators().add(firstTokenAfter(o, TerminalToken.TokenNameCOMMA)); - } - } - arguments.complete( - firstTokenIn(e, TerminalToken.TokenNameLPAREN), - lastTokenIn(e, TerminalToken.TokenNameRPAREN) - ); - } - return new AnnotationTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameAT), - (TypeTree) convertExpression(e.getTypeName()), - arguments - ); - } - - private KeywordSuper unqualifiedKeywordSuper(ASTNode node) { - InternalSyntaxToken token = firstTokenIn(node, TerminalToken.TokenNamesuper); - do { - if (node instanceof AbstractTypeDeclaration abstractTypeDeclaration) { - return keywordSuper(token, abstractTypeDeclaration.resolveBinding()); - } - if (node instanceof AnonymousClassDeclaration anonymousClassDeclaration) { - return keywordSuper(token, anonymousClassDeclaration.resolveBinding()); - } - node = node.getParent(); - } while (true); - } - - private TypeTree convertType(Type node) { - switch (node.getNodeType()) { - case ASTNode.PRIMITIVE_TYPE: - return convertPrimitiveType((PrimitiveType) node); - case ASTNode.SIMPLE_TYPE: - return convertSimpleType((SimpleType) node); - case ASTNode.UNION_TYPE: - return convertUnionType((UnionType) node); - case ASTNode.ARRAY_TYPE: - return convertArrayType((ArrayType) node); - case ASTNode.PARAMETERIZED_TYPE: - return convertParameterizedType((ParameterizedType) node); - case ASTNode.QUALIFIED_TYPE: - return convertQualifiedType((QualifiedType) node); - case ASTNode.NAME_QUALIFIED_TYPE: - return convertNamedQualifiedType((NameQualifiedType) node); - case ASTNode.WILDCARD_TYPE: - return convertWildcardType((WildcardType) node); - default: - throw new IllegalStateException(ASTNode.nodeClassForType(node.getNodeType()).toString()); - } - } - - private JavaTree.PrimitiveTypeTreeImpl convertPrimitiveType(PrimitiveType e) { - final JavaTree.PrimitiveTypeTreeImpl t; - switch (e.getPrimitiveTypeCode().toString()) { - case "byte": - t = new JavaTree.PrimitiveTypeTreeImpl(lastTokenIn(e, TerminalToken.TokenNamebyte)); - break; - case "short": - t = new JavaTree.PrimitiveTypeTreeImpl(lastTokenIn(e, TerminalToken.TokenNameshort)); - break; - case "char": - t = new JavaTree.PrimitiveTypeTreeImpl(lastTokenIn(e, TerminalToken.TokenNamechar)); - break; - case "int": - t = new JavaTree.PrimitiveTypeTreeImpl(lastTokenIn(e, TerminalToken.TokenNameint)); - break; - case "long": - t = new JavaTree.PrimitiveTypeTreeImpl(lastTokenIn(e, TerminalToken.TokenNamelong)); - break; - case "float": - t = new JavaTree.PrimitiveTypeTreeImpl(lastTokenIn(e, TerminalToken.TokenNamefloat)); - break; - case "double": - t = new JavaTree.PrimitiveTypeTreeImpl(lastTokenIn(e, TerminalToken.TokenNamedouble)); - break; - case "boolean": - t = new JavaTree.PrimitiveTypeTreeImpl(lastTokenIn(e, TerminalToken.TokenNameboolean)); - break; - case "void": - t = new JavaTree.PrimitiveTypeTreeImpl(lastTokenIn(e, TerminalToken.TokenNamevoid)); + private IdentifierTreeImpl labelReference(PsiIdentifier label) { + if (label == null) { + return null; + } + var result = identifier(label); + for (var symbol : labels) { + if (symbol.name().equals(result.name())) { + result.labelSymbol = symbol; + symbol.usages.add(result); break; - default: - throw new IllegalStateException(e.getPrimitiveTypeCode().toString()); - } - t.complete(convertAnnotations(e.annotations())); - setType(t, e.resolveBinding()); - return t; - } - - private JavaTree.AnnotatedTypeTree convertSimpleType(SimpleType e) { - List annotations = ((List) e.annotations()).stream() - .map(Annotation.class::cast) - .map(annotation -> (AnnotationTree) convertExpression(annotation)) - .toList(); - JavaTree.AnnotatedTypeTree t = e.isVar() ? convertVarType(e) : (JavaTree.AnnotatedTypeTree) convertExpression(e.getName()); - t.complete(annotations); - // typeBinding is assigned by convertVarType or convertExpression - return t; - } - - private JavaTree.UnionTypeTreeImpl convertUnionType(UnionType e) { - QualifiedIdentifierListTreeImpl alternatives = QualifiedIdentifierListTreeImpl.emptyList(); - for (int i = 0; i < e.types().size(); i++) { - Type o = (Type) e.types().get(i); - alternatives.add(convertType(o)); - if (i < e.types().size() - 1) { - alternatives.separators().add(firstTokenAfter(o, TerminalToken.TokenNameOR)); } } - JavaTree.UnionTypeTreeImpl t = new JavaTree.UnionTypeTreeImpl(alternatives); - setType(t, e.resolveBinding()); - return t; + return result; } - private TypeTree convertArrayType(ArrayType e) { - @Nullable ITypeBinding elementTypeBinding = e.getElementType().resolveBinding(); - TypeTree t = convertType(e.getElementType()); - int tokenIndex = tokenManager.firstIndexAfter(e.getElementType(), TerminalToken.TokenNameLBRACKET); - for (int i = 0; i < e.dimensions().size(); i++) { - if (i > 0) { - tokenIndex = nextTokenIndex(tokenIndex, TerminalToken.TokenNameLBRACKET); - } - t = new JavaTree.ArrayTypeTreeImpl( - t, - (List) convertAnnotations(((Dimension) e.dimensions().get(i)).annotations()), - createSyntaxToken(tokenIndex), - createSyntaxToken(nextTokenIndex(tokenIndex, TerminalToken.TokenNameRBRACKET)) - ); - if (elementTypeBinding != null) { - setType(((JavaTree.ArrayTypeTreeImpl) t), elementTypeBinding.createArrayType(i + 1)); - } - } - return t; - } - - private JavaTree.ParameterizedTypeTreeImpl convertParameterizedType(ParameterizedType e) { - LineColumnConverter.Pos pos = lineColumnConverter.toPos(e.getStartPosition() + e.getLength() - 1); - JavaTree.ParameterizedTypeTreeImpl t = new JavaTree.ParameterizedTypeTreeImpl( - convertType(e.getType()), - convertTypeArguments( - firstTokenAfter(e.getType(), TerminalToken.TokenNameLESS), - e.typeArguments(), - new InternalSyntaxToken( - pos.line(), - pos.columnOffset(), - ">", - /* TODO */ Collections.emptyList(), - false - ) - ) - ); - setType(t, e.resolveBinding()); - return t; - } - - private MemberSelectExpressionTreeImpl convertQualifiedType(QualifiedType e) { - MemberSelectExpressionTreeImpl t = new MemberSelectExpressionTreeImpl( - (ExpressionTree) convertType(e.getQualifier()), - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), - createSimpleName(e.getName()) - ); - ((IdentifierTreeImpl) t.identifier()).complete(convertAnnotations(e.annotations())); - setType(t, e.resolveBinding()); - return t; - } - - private MemberSelectExpressionTreeImpl convertNamedQualifiedType(NameQualifiedType e) { - MemberSelectExpressionTreeImpl t = new MemberSelectExpressionTreeImpl( - convertExpression(e.getQualifier()), - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), - createSimpleName(e.getName()) - ); - ((IdentifierTreeImpl) t.identifier()).complete(convertAnnotations(e.annotations())); - setType(t, e.resolveBinding()); - return t; - } - - private JavaTree.WildcardTreeImpl convertWildcardType(WildcardType e) { - final InternalSyntaxToken questionToken = e.annotations().isEmpty() - ? firstTokenIn(e, TerminalToken.TokenNameQUESTION) - : firstTokenAfter((ASTNode) e.annotations().get(e.annotations().size() - 1), TerminalToken.TokenNameQUESTION); - JavaTree.WildcardTreeImpl t; - Type bound = e.getBound(); - if (bound == null) { - t = new JavaTree.WildcardTreeImpl(questionToken); - } else { - boolean isUpperBound = e.isUpperBound(); - t = new JavaTree.WildcardTreeImpl( - isUpperBound ? Tree.Kind.EXTENDS_WILDCARD : Tree.Kind.SUPER_WILDCARD, - firstTokenBefore(bound, isUpperBound ? TerminalToken.TokenNameextends : TerminalToken.TokenNamesuper), - convertType(bound) - ).complete(questionToken); + private AssertStatementTreeImpl assertion(PsiAssertStatement assertion) { + var result = new AssertStatementTreeImpl(token(assertion, "assert"), expression(assertion.getAssertCondition()), last(assertion, ";")); + if (assertion.getAssertDescription() != null) { + result.complete(tokens.find(end(assertion.getAssertCondition()), start(assertion.getAssertDescription()), ":", false), expression(assertion.getAssertDescription())); } - t.complete(convertAnnotations(e.annotations())); - setType(t, e.resolveBinding()); - return t; + return result; } - @Nullable - private static IMethodBinding excludeRecovery(@Nullable IMethodBinding methodBinding, int arguments) { - if (methodBinding == null) { - return null; - } - if (methodBinding.isVarargs()) { - if (arguments + 1 < methodBinding.getParameterTypes().length) { - return null; + /** Reparse C-style resource dimensions as local syntax because PSI truncates this ECJ-supported resource form. */ + private VariableTreeImpl resourceVariable(PsiTryStatement tried, PsiResourceVariable variable) { + if (variable.getInitializer() != null || !tokens.at(end(variable.getNameIdentifier())).text().equals("[")) { + return variable(variable); + } + var resourceList = tried.getResourceList(); + var repaired = new StringBuilder(source); + int open = offset(token(resourceList, "(")); + int close = offset(last(resourceList, ")")); + for (int i = start(tried); i <= open; i++) { + repaired.setCharAt(i, ' '); + } + repaired.setCharAt(close, ';'); + var reparsed = PsiFileFactory.getInstance(file.getProject()).createFileFromText(file.getName(), file.getFileType(), repaired); + ((com.intellij.psi.impl.source.PsiFileImpl) reparsed).setOriginalFile(file); + var declaration = PsiTreeUtil.getParentOfType(reparsed.findElementAt(start(variable)), PsiLocalVariable.class); + if (declaration == null || declaration.getInitializer() == null) { + throw unsupported(variable); + } + return variable(declaration); + } + + private TryStatementTreeImpl tryStatement(PsiTryStatement tried) { + var resources = ResourceListTreeImpl.emptyList(); + var sourceResources = tried.getResourceList(); + if (sourceResources != null) { + for (var resource : sourceResources) { + if (resource instanceof PsiResourceVariable variable) { + resources.add(resourceVariable(tried, variable)); + } else if (resource instanceof PsiResourceExpression expression) { + resources.add(expression(expression.getExpression())); + } else { + throw unsupported(resource); + } + if (tokens.at(end(resource)).text().equals(";")) { + resources.separators().add(tokens.at(end(resource))); + } } - } else { - if (arguments != methodBinding.getParameterTypes().length) { - return null; + } + List catches = new ArrayList<>(); + for (var caught : tried.getCatchSections()) { + catches.add(remember(caught, new CatchTreeImpl(token(caught, "catch"), token(caught, "("), variable(caught.getParameter()), + tokens.find(end(caught.getParameter()), start(caught.getCatchBlock()), ")", false), block(caught.getCatchBlock())))); + } + var finallyBlock = tried.getFinallyBlock(); + return new TryStatementTreeImpl(token(tried, "try"), resources.isEmpty() ? null : token(sourceResources, "("), resources, + resources.isEmpty() ? null : last(sourceResources, ")"), block(tried.getTryBlock()), catches, + finallyBlock == null ? null : tokens.find(end(tried.getTryBlock()), start(finallyBlock), "finally", true), finallyBlock == null ? null : block(finallyBlock)); + } + + private List switchGroups(PsiSwitchBlock switched) { + List result = new ArrayList<>(); + List labels = new ArrayList<>(); + var body = StatementListTreeImpl.emptyList(); + for (var statement : switched.getBody().getStatements()) { + if (statement instanceof PsiSwitchLabelStatementBase label) { + if (!body.isEmpty()) { + result.add(new CaseGroupTreeImpl(labels, body)); + labels = new ArrayList<>(); + body = StatementListTreeImpl.emptyList(); + } + List expressions = new ArrayList<>(); + var list = label.getCaseLabelElementList(); + if (list != null) { + for (var element : list.getElements()) { + ExpressionTree expression; + if (element instanceof PsiPattern pattern) { + expression = pattern(pattern); + if (label.getGuardExpression() != null) { + expression = remember(pattern, new GuardedPatternTreeImpl((PatternTree) expression, + tokens.find(end(element), start(label.getGuardExpression()), "when", false), expression(label.getGuardExpression()), SemanticValues.UNKNOWN_TYPE)); + } + } else if (element instanceof PsiDefaultCaseLabelElement) { + expression = new DefaultPatternTreeImpl(token(element, "default"), SemanticValues.UNKNOWN_TYPE); + } else if (element instanceof PsiLiteralExpression literal && literal.textMatches("null")) { + expression = new NullPatternTreeImpl(literal(literal)); + } else { + expression = expression(element); + } + expressions.add(expression); + } + } + var separator = label instanceof PsiSwitchLabeledRuleStatement rule ? tokens.find(start(label), start(rule.getBody()), "->", true) : last(label, ":"); + labels.add(new CaseLabelTreeImpl(token(label, label.isDefaultCase() ? "default" : "case"), expressions, separator)); + if (label instanceof PsiSwitchLabeledRuleStatement rule) { + var ruleBody = rule.getBody(); + if (ruleBody instanceof PsiExpressionStatement expression) { + body.add(new YieldStatementTreeImpl(null, expression(expression.getExpression()), last(expression, ";"))); + } else { + addStatement(ruleBody, body, true); + } + } + } else { + addStatement(statement, body, true); } } - return methodBinding; + if (!labels.isEmpty()) { + result.add(new CaseGroupTreeImpl(labels, body)); + } + return result; } - @Nullable - private static IMethodBinding findConstructorForAnonymousClass(AST ast, @Nullable ITypeBinding typeBinding, @Nullable IMethodBinding methodBinding) { - if (typeBinding == null || methodBinding == null) { - return null; - } - if (typeBinding.isInterface()) { - typeBinding = ast.resolveWellKnownType("java.lang.Object"); - } - return Stream.of(typeBinding.getDeclaredMethods()) - .filter(methodBinding::isSubsignature) - .findFirst() - .orElse(null); - } - - private List convertAnnotations(List e) { - return e.stream() - .map(o -> (AnnotationTree) convertExpression((Annotation) o)) - .toList(); - } - - private ModifiersTreeImpl convertModifiers(List source) { - return new ModifiersTreeImpl(source.stream() - .map(o -> convertModifier((IExtendedModifier) o)) - .toList()); - } - - private ModifierTree convertModifier(IExtendedModifier node) { - switch (((ASTNode) node).getNodeType()) { - case ASTNode.NORMAL_ANNOTATION, - ASTNode.MARKER_ANNOTATION, - ASTNode.SINGLE_MEMBER_ANNOTATION: - return (AnnotationTree) convertExpression((Expression) node); - case ASTNode.MODIFIER: - return convertModifier((org.eclipse.jdt.core.dom.Modifier) node); - default: - throw new IllegalStateException(ASTNode.nodeClassForType(((ASTNode) node).getNodeType()).toString()); - } - } - - private ModifierTree convertModifier(org.eclipse.jdt.core.dom.Modifier node) { - switch (node.getKeyword().toString()) { - case "public": - return new ModifierKeywordTreeImpl(Modifier.PUBLIC, firstTokenIn(node, TerminalToken.TokenNamepublic)); - case "protected": - return new ModifierKeywordTreeImpl(Modifier.PROTECTED, firstTokenIn(node, TerminalToken.TokenNameprotected)); - case "private": - return new ModifierKeywordTreeImpl(Modifier.PRIVATE, firstTokenIn(node, TerminalToken.TokenNameprivate)); - case "static": - return new ModifierKeywordTreeImpl(Modifier.STATIC, firstTokenIn(node, TerminalToken.TokenNamestatic)); - case "abstract": - return new ModifierKeywordTreeImpl(Modifier.ABSTRACT, firstTokenIn(node, TerminalToken.TokenNameabstract)); - case "final": - return new ModifierKeywordTreeImpl(Modifier.FINAL, firstTokenIn(node, TerminalToken.TokenNamefinal)); - case "native": - return new ModifierKeywordTreeImpl(Modifier.NATIVE, firstTokenIn(node, TerminalToken.TokenNamenative)); - case "synchronized": - return new ModifierKeywordTreeImpl(Modifier.SYNCHRONIZED, firstTokenIn(node, TerminalToken.TokenNamesynchronized)); - case "transient": - return new ModifierKeywordTreeImpl(Modifier.TRANSIENT, firstTokenIn(node, TerminalToken.TokenNametransient)); - case "volatile": - return new ModifierKeywordTreeImpl(Modifier.VOLATILE, firstTokenIn(node, TerminalToken.TokenNamevolatile)); - case "strictfp": - return new ModifierKeywordTreeImpl(Modifier.STRICTFP, firstTokenIn(node, TerminalToken.TokenNamestrictfp)); - case "default": - return new ModifierKeywordTreeImpl(Modifier.DEFAULT, firstTokenIn(node, TerminalToken.TokenNamedefault)); - case "sealed": - return new ModifierKeywordTreeImpl(Modifier.SEALED, firstTokenIn(node, TerminalToken.TokenNameRestrictedIdentifiersealed)); - case "non-sealed": { - return new ModifierKeywordTreeImpl(Modifier.NON_SEALED, firstTokenIn(node, TerminalToken.TokenNamenon_sealed)); - } - default: - throw new IllegalStateException(node.getKeyword().toString()); - } - } - - private static final TerminalToken ANY_TOKEN = TerminalToken.TokenNameInvalid; - - private static final Map operators = new HashMap<>(); - - private static class Op { - final Tree.Kind kind; - - /** - * {@link TerminalToken} - */ - final TerminalToken tokenType; - - Op(Tree.Kind kind, TerminalToken tokenType) { - this.kind = kind; - this.tokenType = tokenType; - } - } - - static { - operators.put(PrefixExpression.Operator.PLUS, new Op(Tree.Kind.UNARY_PLUS, TerminalToken.TokenNamePLUS)); - operators.put(PrefixExpression.Operator.MINUS, new Op(Tree.Kind.UNARY_MINUS, TerminalToken.TokenNameMINUS)); - operators.put(PrefixExpression.Operator.NOT, new Op(Tree.Kind.LOGICAL_COMPLEMENT, TerminalToken.TokenNameNOT)); - operators.put(PrefixExpression.Operator.COMPLEMENT, new Op(Tree.Kind.BITWISE_COMPLEMENT, TerminalToken.TokenNameTWIDDLE)); - operators.put(PrefixExpression.Operator.DECREMENT, new Op(Tree.Kind.PREFIX_DECREMENT, TerminalToken.TokenNameMINUS_MINUS)); - operators.put(PrefixExpression.Operator.INCREMENT, new Op(Tree.Kind.PREFIX_INCREMENT, TerminalToken.TokenNamePLUS_PLUS)); - - operators.put(PostfixExpression.Operator.DECREMENT, new Op(Tree.Kind.POSTFIX_DECREMENT, TerminalToken.TokenNameMINUS_MINUS)); - operators.put(PostfixExpression.Operator.INCREMENT, new Op(Tree.Kind.POSTFIX_INCREMENT, TerminalToken.TokenNamePLUS_PLUS)); - - operators.put(InfixExpression.Operator.TIMES, new Op(Tree.Kind.MULTIPLY, TerminalToken.TokenNameMULTIPLY)); - operators.put(InfixExpression.Operator.DIVIDE, new Op(Tree.Kind.DIVIDE, TerminalToken.TokenNameDIVIDE)); - operators.put(InfixExpression.Operator.REMAINDER, new Op(Tree.Kind.REMAINDER, TerminalToken.TokenNameREMAINDER)); - operators.put(InfixExpression.Operator.PLUS, new Op(Tree.Kind.PLUS, TerminalToken.TokenNamePLUS)); - operators.put(InfixExpression.Operator.MINUS, new Op(Tree.Kind.MINUS, TerminalToken.TokenNameMINUS)); - operators.put(InfixExpression.Operator.LEFT_SHIFT, new Op(Tree.Kind.LEFT_SHIFT, TerminalToken.TokenNameLEFT_SHIFT)); - operators.put(InfixExpression.Operator.RIGHT_SHIFT_SIGNED, new Op(Tree.Kind.RIGHT_SHIFT, TerminalToken.TokenNameRIGHT_SHIFT)); - operators.put(InfixExpression.Operator.RIGHT_SHIFT_UNSIGNED, new Op(Tree.Kind.UNSIGNED_RIGHT_SHIFT, TerminalToken.TokenNameUNSIGNED_RIGHT_SHIFT)); - operators.put(InfixExpression.Operator.LESS, new Op(Tree.Kind.LESS_THAN, TerminalToken.TokenNameLESS)); - operators.put(InfixExpression.Operator.GREATER, new Op(Tree.Kind.GREATER_THAN, TerminalToken.TokenNameGREATER)); - operators.put(InfixExpression.Operator.LESS_EQUALS, new Op(Tree.Kind.LESS_THAN_OR_EQUAL_TO, TerminalToken.TokenNameLESS_EQUAL)); - operators.put(InfixExpression.Operator.GREATER_EQUALS, new Op(Tree.Kind.GREATER_THAN_OR_EQUAL_TO, TerminalToken.TokenNameGREATER_EQUAL)); - operators.put(InfixExpression.Operator.EQUALS, new Op(Tree.Kind.EQUAL_TO, TerminalToken.TokenNameEQUAL_EQUAL)); - operators.put(InfixExpression.Operator.NOT_EQUALS, new Op(Tree.Kind.NOT_EQUAL_TO, TerminalToken.TokenNameNOT_EQUAL)); - operators.put(InfixExpression.Operator.XOR, new Op(Tree.Kind.XOR, TerminalToken.TokenNameXOR)); - operators.put(InfixExpression.Operator.OR, new Op(Tree.Kind.OR, TerminalToken.TokenNameOR)); - operators.put(InfixExpression.Operator.AND, new Op(Tree.Kind.AND, TerminalToken.TokenNameAND)); - operators.put(InfixExpression.Operator.CONDITIONAL_OR, new Op(Tree.Kind.CONDITIONAL_OR, TerminalToken.TokenNameOR_OR)); - operators.put(InfixExpression.Operator.CONDITIONAL_AND, new Op(Tree.Kind.CONDITIONAL_AND, TerminalToken.TokenNameAND_AND)); - - operators.put(Assignment.Operator.ASSIGN, new Op(Tree.Kind.ASSIGNMENT, TerminalToken.TokenNameEQUAL)); - operators.put(Assignment.Operator.PLUS_ASSIGN, new Op(Tree.Kind.PLUS_ASSIGNMENT, TerminalToken.TokenNamePLUS_EQUAL)); - operators.put(Assignment.Operator.MINUS_ASSIGN, new Op(Tree.Kind.MINUS_ASSIGNMENT, TerminalToken.TokenNameMINUS_EQUAL)); - operators.put(Assignment.Operator.TIMES_ASSIGN, new Op(Tree.Kind.MULTIPLY_ASSIGNMENT, TerminalToken.TokenNameMULTIPLY_EQUAL)); - operators.put(Assignment.Operator.DIVIDE_ASSIGN, new Op(Tree.Kind.DIVIDE_ASSIGNMENT, TerminalToken.TokenNameDIVIDE_EQUAL)); - operators.put(Assignment.Operator.BIT_AND_ASSIGN, new Op(Tree.Kind.AND_ASSIGNMENT, TerminalToken.TokenNameAND_EQUAL)); - operators.put(Assignment.Operator.BIT_OR_ASSIGN, new Op(Tree.Kind.OR_ASSIGNMENT, TerminalToken.TokenNameOR_EQUAL)); - operators.put(Assignment.Operator.BIT_XOR_ASSIGN, new Op(Tree.Kind.XOR_ASSIGNMENT, TerminalToken.TokenNameXOR_EQUAL)); - operators.put(Assignment.Operator.REMAINDER_ASSIGN, new Op(Tree.Kind.REMAINDER_ASSIGNMENT, TerminalToken.TokenNameREMAINDER_EQUAL)); - operators.put(Assignment.Operator.LEFT_SHIFT_ASSIGN, new Op(Tree.Kind.LEFT_SHIFT_ASSIGNMENT, TerminalToken.TokenNameLEFT_SHIFT_EQUAL)); - operators.put(Assignment.Operator.RIGHT_SHIFT_SIGNED_ASSIGN, new Op(Tree.Kind.RIGHT_SHIFT_ASSIGNMENT, TerminalToken.TokenNameRIGHT_SHIFT_EQUAL)); - operators.put(Assignment.Operator.RIGHT_SHIFT_UNSIGNED_ASSIGN, new Op(Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT, TerminalToken.TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL)); + private SwitchStatementTreeImpl switchStatement(PsiSwitchStatement statement) { + return new SwitchStatementTreeImpl(token(statement, "switch"), token(statement, "("), expression(statement.getExpression()), + tokens.find(end(statement.getExpression()), start(statement.getBody()), ")", false), exact(statement.getBody().getLBrace()), switchGroups(statement), exact(statement.getBody().getRBrace())); + } + + private SwitchExpressionTreeImpl switchExpression(PsiSwitchExpression expression) { + return new SwitchExpressionTreeImpl(token(expression, "switch"), token(expression, "("), expression(expression.getExpression()), + tokens.find(end(expression.getExpression()), start(expression.getBody()), ")", false), exact(expression.getBody().getLBrace()), switchGroups(expression), exact(expression.getBody().getRBrace())); } } diff --git a/java-frontend/src/main/java/org/sonar/java/model/JParserConfig.java b/java-frontend/src/main/java/org/sonar/java/model/JParserConfig.java index 8debd5fa9a2..402d1272afc 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/JParserConfig.java +++ b/java-frontend/src/main/java/org/sonar/java/model/JParserConfig.java @@ -24,8 +24,8 @@ import java.util.function.BiConsumer; import java.util.function.BooleanSupplier; import java.util.stream.StreamSupport; +import org.apache.commons.lang3.exception.ExceptionUtils; import org.eclipse.core.runtime.OperationCanceledException; -import org.eclipse.jdt.core.dom.ASTParser; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.sonar.api.batch.fs.InputFile; @@ -97,12 +97,8 @@ public JavaTree.CompilationUnitTreeImpl get() throws Exception { } } - public ASTParser astParser() { - return EcjFrontendBackend.newParser(configuration); - } - FrontendBackend backend() { - return new EcjFrontendBackend(this::astParser); + return new PsiFrontendBackend(); } final FrontendSession openSession() { @@ -133,6 +129,8 @@ public void parse(Iterable inputFiles, BooleanSupplier isCa Result result; try { result = new Result(unit.convert()); + } catch (OperationCanceledException e) { + throw e; } catch (Exception e) { result = new Result(e); } @@ -151,6 +149,9 @@ public void parse(Iterable inputFiles, BooleanSupplier isCa } catch (OperationCanceledException e) { throw e; } catch (RuntimeException e) { + if (Thread.currentThread().isInterrupted() || ExceptionUtils.getThrowableList(e).stream().anyMatch(OperationCanceledException.class::isInstance)) { + throw e; + } LOG.warn("Unexpected {}: {}", e.getClass().getSimpleName(), e.getMessage()); if (!notYetAnalyzedFiles.isEmpty()) { fallbackToFileByFileMode(notYetAnalyzedFiles.stream().toList(), isCanceled, action); @@ -166,6 +167,9 @@ public void parse(Iterable inputFiles, BooleanSupplier isCa private void fallbackToFileByFileMode(List inputFiles, BooleanSupplier isCanceled, BiConsumer action) { LOG.warn("Fallback to file by file analysis for {} files", inputFiles.size()); for (InputFile inputFile : inputFiles) { + if (Thread.currentThread().isInterrupted()) { + throw new OperationCanceledException("Java analysis interrupted"); + } if (isCanceled.getAsBoolean()) { break; } @@ -197,6 +201,9 @@ public void parse(Iterable inputFiles, BooleanSupplier isCa progressReport.start(filesNames); try { for (InputFile inputFile : inputFiles) { + if (Thread.currentThread().isInterrupted()) { + throw new OperationCanceledException("Java analysis interrupted"); + } if (isCanceled.getAsBoolean()) { cancelled = true; break; @@ -224,6 +231,8 @@ private static void parse(FrontendSession session, InputFile inputFile, BiConsum PerformanceMeasure.Duration parseDuration = PerformanceMeasure.start("JParser"); try { result = new Result(session.parse(inputFile.filename(), inputFile.contents())); + } catch (OperationCanceledException e) { + throw e; } catch (Exception e) { result = new Result(e); } finally { diff --git a/java-frontend/src/main/java/org/sonar/java/model/JSema.java b/java-frontend/src/main/java/org/sonar/java/model/JSema.java index 0f0cfa11c5d..3b83d2b81ed 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/JSema.java +++ b/java-frontend/src/main/java/org/sonar/java/model/JSema.java @@ -16,21 +16,48 @@ */ package org.sonar.java.model; +import com.intellij.openapi.project.Project; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.JavaResolveResult; +import com.intellij.psi.LambdaUtil; +import com.intellij.psi.PsiAnonymousClass; +import com.intellij.psi.PsiArrayType; +import com.intellij.psi.PsiCapturedWildcardType; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiClassInitializer; +import com.intellij.psi.PsiClassType; +import com.intellij.psi.PsiCompiledElement; +import com.intellij.psi.PsiDisjunctionType; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiField; +import com.intellij.psi.PsiIntersectionType; +import com.intellij.psi.PsiJavaFile; +import com.intellij.psi.PsiLambdaExpression; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiMethodCallExpression; +import com.intellij.psi.PsiModifier; +import com.intellij.psi.PsiNewExpression; +import com.intellij.psi.PsiPackage; +import com.intellij.psi.PsiParameter; +import com.intellij.psi.PsiSubstitutor; +import com.intellij.psi.PsiTypeParameter; +import com.intellij.psi.PsiTypeParameterListOwner; +import com.intellij.psi.PsiTypes; +import com.intellij.psi.PsiVariable; +import com.intellij.psi.PsiWildcardType; +import com.intellij.psi.impl.light.LightDefaultConstructor; +import com.intellij.psi.infos.MethodCandidateInfo; +import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.psi.util.PsiTreeUtil; +import java.util.ArrayList; import java.util.Arrays; -import java.util.Collections; +import java.util.Comparator; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.function.Supplier; -import javax.annotation.Nullable; -import org.eclipse.jdt.core.dom.AST; -import org.eclipse.jdt.core.dom.ASTUtils; -import org.eclipse.jdt.core.dom.IAnnotationBinding; -import org.eclipse.jdt.core.dom.IBinding; -import org.eclipse.jdt.core.dom.IMethodBinding; -import org.eclipse.jdt.core.dom.IPackageBinding; -import org.eclipse.jdt.core.dom.ITypeBinding; -import org.eclipse.jdt.core.dom.IVariableBinding; +import org.sonar.java.psi.JavaPsiEnvironment; import org.sonar.plugins.java.api.semantic.Sema; import org.sonar.plugins.java.api.semantic.Symbol; import org.sonar.plugins.java.api.semantic.Type; @@ -38,184 +65,345 @@ import org.sonar.plugins.java.api.tree.Tree; public final class JSema implements Sema { + final Project project; + final PsiJavaFile file; + final boolean explicitRuntime; + private final JavaPsiEnvironment environment; + private final Runnable cleaner; + private final Map types = new HashMap<>(); + private final Map symbols = new HashMap<>(); + private final Map namedTypes = new HashMap<>(); + final Map declarations = new LinkedHashMap<>(); + final Map> usages = new LinkedHashMap<>(); + private final Map initializers = new HashMap<>(); - private final AST ast; - @Nullable - private Runnable environmentCleaner; - final Map declarations = new HashMap<>(); - final Map> usages = new HashMap<>(); - private final Map types = new HashMap<>(); - private final Map symbols = new HashMap<>(); - private final Map initializerBlockSymbols = new HashMap<>(); - private final Map staticInitializerBlockSymbols = new HashMap<>(); - private final Map annotations = new HashMap<>(); - private final Map nameToTypeCache = new HashMap<>(); - - JSema(AST ast) { - this(ast, null); + JSema(JavaPsiEnvironment environment, Project project, PsiJavaFile file, Runnable cleaner, boolean explicitRuntime) { + this.environment = environment; + this.project = project; + this.file = file; + this.cleaner = cleaner; + this.explicitRuntime = explicitRuntime; } - JSema(AST ast, @Nullable Runnable environmentCleaner) { - this.ast = ast; - this.environmentCleaner = environmentCleaner; + T read(Supplier action) { + return PsiFrontendBackend.cancellable(() -> environment.read((unused, files) -> action.get())); } - Supplier typeSupplier(@Nullable ITypeBinding binding) { - return binding == null ? SemanticValues.UNKNOWN_TYPE : new EcjSemanticAttachment<>(binding, this::type); + @Override + public Runnable getEnvironmentCleaner() { + return cleaner; } - Supplier methodSupplier(@Nullable IMethodBinding binding) { - return binding == null ? SemanticValues.UNKNOWN_METHOD : new EcjSemanticAttachment<>(binding, this::methodSymbol); + @Override + public Type getClassType(String name) { + return read(() -> { + Type cached = namedTypes.get(name); + if (cached != null) { + return cached; + } + com.intellij.psi.PsiType resolved = resolveType(name); + Type result = resolved == null ? Type.UNKNOWN : type(resolved); + namedTypes.put(name, result); + return result; + }); } - Supplier symbolSupplier(@Nullable IBinding binding) { - return binding == null ? SemanticValues.UNKNOWN_SYMBOL : new EcjSemanticAttachment<>(binding, this::symbol); + com.intellij.psi.PsiType resolveType(String name) { + if (name.isEmpty()) { + return null; + } + if (name.endsWith("[]")) { + var component = resolveType(name.substring(0, name.length() - 2)); + return component == null ? null : component.createArrayType(); + } + var primitive = switch (name) { + case "boolean" -> PsiTypes.booleanType(); + case "byte" -> PsiTypes.byteType(); + case "short" -> PsiTypes.shortType(); + case "char" -> PsiTypes.charType(); + case "int" -> PsiTypes.intType(); + case "long" -> PsiTypes.longType(); + case "float" -> PsiTypes.floatType(); + case "double" -> PsiTypes.doubleType(); + case "void" -> PsiTypes.voidType(); + default -> null; + }; + if (primitive != null) { + return primitive; + } + var cls = JavaPsiFacade.getInstance(project).findClass(name.replace('$', '.'), GlobalSearchScope.allScope(project)); + return cls == null ? null : declarationType(cls); } - private Symbol symbol(IBinding binding) { - return switch (binding.getKind()) { - case IBinding.TYPE -> typeSymbol((ITypeBinding) binding); - case IBinding.METHOD -> methodSymbol((IMethodBinding) binding); - case IBinding.VARIABLE -> variableSymbol((IVariableBinding) binding); - case IBinding.PACKAGE -> packageSymbol((IPackageBinding) binding); - default -> Symbol.UNKNOWN_SYMBOL; - }; + PsiClassType declarationType(PsiClass cls) { + var factory = JavaPsiFacade.getElementFactory(project); + PsiSubstitutor substitutor = PsiSubstitutor.EMPTY; + for (var current = cls; current != null; current = current.getContainingClass()) { + for (var parameter : current.getTypeParameters()) { + substitutor = substitutor.put(parameter, factory.createType(parameter)); + } + } + return factory.createType(cls, substitutor); } - public JType type(ITypeBinding typeBinding) { - JType cached = types.get(typeBinding); - if (cached != null) { - return cached; + Type type(com.intellij.psi.PsiType value) { + if (value == null) { + return Type.UNKNOWN; + } + if (value instanceof PsiDisjunctionType disjunction) { + return type(disjunction.getLeastUpperBound()); } - return types.computeIfAbsent(typeBinding, k -> new JType(this, JType.normalize(k))); + String key = typeKey(value); + JType cached = types.get(key); + if (cached == null) { + cached = new JType(this, value, key); + types.put(key, cached); + } + return cached; + } + + List types(com.intellij.psi.PsiType[] values) { + return Arrays.stream(values).map(this::type).toList(); } - List types(ITypeBinding[] typeBindings) { - if (typeBindings.length == 0) { - return Collections.emptyList(); + /** Structural keys terminate at type-parameter declarations rather than following their recursive bounds. */ + String typeKey(com.intellij.psi.PsiType type) { + if (type instanceof PsiArrayType array) { + return "[" + typeKey(array.getComponentType()); + } + if (type instanceof PsiCapturedWildcardType captured) { + return "capture:" + key(captured.getContext()) + ":" + key(captured.getTypeParameter()) + ":" + typeKey(captured.getWildcard()); } - Type[] result = new Type[typeBindings.length]; - for (int i = 0; i < typeBindings.length; i++) { - result[i] = type(typeBindings[i]); + if (type instanceof PsiWildcardType wildcard) { + return "wild:" + wildcard.isExtends() + ":" + (wildcard.getBound() == null ? "" : typeKey(wildcard.getBound())); } - return Arrays.asList(result); + if (type instanceof PsiIntersectionType intersection) { + return "intersection:" + Arrays.stream(intersection.getConjuncts()).map(this::typeKey).sorted().toList(); + } + if (type instanceof PsiClassType cls) { + var result = cls.resolveGenerics(); + var declaration = result.getElement(); + if (declaration == null) { + return "recovered:" + cls.getCanonicalText(false); + } + if (declaration instanceof PsiTypeParameter) { + return "parameter:" + key(declaration); + } + return "class:" + key(declaration) + ":" + substitutionKey(result.getSubstitutor(), declaration); + } + return type.getCanonicalText(false); } - public Symbol packageSymbol(@Nullable IPackageBinding packageBinding) { - if (packageBinding == null) { - return Symbol.ROOT_PACKAGE; + String substitutionKey(PsiSubstitutor substitutor, PsiTypeParameterListOwner owner) { + List arguments = new ArrayList<>(); + for (var parameter : owner.getTypeParameters()) { + var argument = substitutor.substitute(parameter); + arguments.add(argument == null ? "raw" : typeKey(argument)); } - JSymbol cached = symbols.get(packageBinding); - if (cached != null) { - return cached; + if (owner instanceof PsiClass cls && cls.getContainingClass() != null && !cls.hasModifierProperty(PsiModifier.STATIC)) { + arguments.add(substitutionKey(substitutor, cls.getContainingClass())); } - return symbols.computeIfAbsent(packageBinding, k -> new JPackageSymbol(this, (IPackageBinding) k)); + return arguments.toString(); } - public JTypeSymbol typeSymbol(ITypeBinding typeBinding) { - JTypeSymbol cached = (JTypeSymbol) symbols.get(typeBinding); - if (cached != null) { - return cached; + String key(PsiElement element) { + if (element == null) { + return "root"; + } + if (element instanceof PsiPackage pkg) { + return "package:" + pkg.getQualifiedName(); + } + if (element instanceof PsiClass cls && cls.getQualifiedName() != null) { + return "class:" + cls.getQualifiedName(); + } + if (element instanceof PsiMethod method) { + return key(method.getContainingClass()) + "#" + method.getName() + ":" + + Arrays.stream(method.getParameterList().getParameters()).map(p -> p.getType().getCanonicalText(false)).toList(); + } + if (element instanceof PsiField field) { + return key(field.getContainingClass()) + ":field:" + field.getName(); + } + if (element instanceof PsiParameter parameter && parameter.getDeclarationScope() instanceof PsiMethod method) { + return key(method) + ":argument:" + method.getParameterList().getParameterIndex(parameter); } - return (JTypeSymbol) symbols.computeIfAbsent(typeBinding, k -> new JTypeSymbol(this, JType.normalize((ITypeBinding) k))); + if (element instanceof PsiTypeParameter parameter) { + return key((PsiElement) parameter.getOwner()) + ":parameter:" + parameter.getIndex(); + } + var containingFile = element.getContainingFile() == null ? null : element.getContainingFile().getOriginalFile(); + String path = containingFile == null ? "" : containingFile.getVirtualFile() == null ? containingFile.getName() : containingFile.getVirtualFile().getPath(); + return path + ":" + element.getTextRange().getStartOffset() + ":" + (element instanceof PsiVariable ? "variable" : element.getClass().getSimpleName()); } - public JMethodSymbol methodSymbol(IMethodBinding methodBinding) { - JMethodSymbol cached = (JMethodSymbol) symbols.get(methodBinding); - if (cached != null) { - return cached; + Symbol symbol(PsiElement element) { + if (element == null) { + return Symbol.UNKNOWN_SYMBOL; + } + if (element instanceof PsiClass cls) { + return type(declarationType(cls)).symbol(); } - return (JMethodSymbol) symbols.computeIfAbsent(methodBinding, k -> new JMethodSymbol(this, (IMethodBinding) k)); + if (element instanceof PsiMethod method) { + return method(method, PsiSubstitutor.EMPTY); + } + String key = key(element); + var cached = symbols.get(key); + if (cached == null) { + if (element instanceof PsiVariable variable) { + return variable(variable, PsiSubstitutor.EMPTY); + } else if (element instanceof PsiPackage pkg) { + cached = new JPackageSymbol(this, pkg, key); + } else { + return Symbol.UNKNOWN_SYMBOL; + } + symbols.put(key, cached); + } + return cached; } - public JInitializerBlockSymbol initializerBlockSymbol(JTypeSymbol owner) { - JInitializerBlockSymbol cached = initializerBlockSymbols.get(owner); - if (cached != null) { - return cached; + JVariableSymbol variable(PsiVariable variable, PsiSubstitutor substitutor) { + if (variable instanceof PsiField field) { + substitutor = completeSubstitutor(substitutor, field.getContainingClass()); + } + String key = key(variable) + (variable instanceof PsiField field ? ":" + substitutionKey(substitutor, field.getContainingClass()) : ""); + var cached = symbols.get(key); + if (cached == null) { + cached = new JVariableSymbol(this, variable, substitutor, key); + symbols.put(key, cached); } - return initializerBlockSymbols.computeIfAbsent(owner, k -> new JInitializerBlockSymbol(k, false)); + return (JVariableSymbol) cached; } - public JInitializerBlockSymbol staticInitializerBlockSymbol(JTypeSymbol owner) { - JInitializerBlockSymbol cached = staticInitializerBlockSymbols.get(owner); - if (cached != null) { - return cached; + JTypeSymbol typeSymbol(JType type) { + String key = "type:" + type.key; + var cached = symbols.get(key); + if (cached == null) { + cached = new JTypeSymbol(this, type, key); + symbols.put(key, cached); } - return staticInitializerBlockSymbols.computeIfAbsent(owner, k -> new JInitializerBlockSymbol(k, true)); + return (JTypeSymbol) cached; } + Symbol.MethodSymbol method(JavaResolveResult result) { + return result.isValidResult() && result.getElement() instanceof PsiMethod method + ? method(method, result.getSubstitutor()) : Symbol.MethodSymbol.UNKNOWN_METHOD; + } - public JVariableSymbol variableSymbol(IVariableBinding variableBinding) { - JVariableSymbol cached = (JVariableSymbol) symbols.get(variableBinding); - if (cached != null) { - return cached; + Symbol.MethodSymbol method(PsiMethodCallExpression call) { + var resolved = call.resolveMethodGenerics(); + if (resolved.isValidResult()) { + return method(resolved); } - return (JVariableSymbol) symbols.computeIfAbsent(variableBinding, k -> new JVariableSymbol(this, (IVariableBinding) k)); + var candidates = call.getMethodExpression().multiResolve(false); + if (candidates.length == 1 && candidates[0].getElement() instanceof PsiMethod method + && (method.isVarArgs() || method.getParameterList().getParametersCount() == call.getArgumentList().getExpressionCount())) { + return method(method, candidates[0].getSubstitutor()); + } + return Arrays.stream(candidates) + .filter(result -> result.isAccessible() && result.isStaticsScopeCorrect() + && result instanceof MethodCandidateInfo candidate && candidate.isApplicable()) + .min(Comparator.comparingInt(result -> result.getElement() instanceof PsiCompiledElement ? Integer.MAX_VALUE : result.getElement().getTextOffset())) + .map(result -> (Symbol.MethodSymbol) method((PsiMethod) result.getElement(), result.getSubstitutor())) + .orElse(Symbol.MethodSymbol.UNKNOWN_METHOD); } - EcjSymbolMetadata.JAnnotationInstance annotation(IAnnotationBinding annotationBinding) { - EcjSymbolMetadata.JAnnotationInstance cached = annotations.get(annotationBinding); - if (cached != null) { - return cached; + Symbol.MethodSymbol constructor(PsiNewExpression expression) { + var result = expression.resolveMethodGenerics(); + if (result.isValidResult()) { + return method(result); + } + var reference = expression.getClassReference(); + var resolved = reference == null ? JavaResolveResult.EMPTY : reference.advancedResolve(false); + if (resolved.isValidResult() && resolved.getElement() instanceof PsiClass cls && expression.getArgumentList() != null + && expression.getArgumentList().isEmpty()) { + var constructor = LightDefaultConstructor.create(cls); + if (constructor != null) { + return method(constructor, resolved.getSubstitutor()); + } } - return annotations.computeIfAbsent(annotationBinding, k -> new EcjSymbolMetadata.JAnnotationInstance(this, k)); + return Symbol.MethodSymbol.UNKNOWN_METHOD; } - static IBinding declarationBinding(IBinding binding) { - switch (binding.getKind()) { - case IBinding.TYPE: - return ((ITypeBinding) binding).getTypeDeclaration(); - case IBinding.METHOD: - return ((IMethodBinding) binding).getMethodDeclaration(); - case IBinding.VARIABLE: - return ((IVariableBinding) binding).getVariableDeclaration(); - default: - return binding; + JMethodSymbol method(PsiMethod method, PsiSubstitutor substitutor) { + substitutor = completeSubstitutor(substitutor, method); + String key = key(method) + ":" + substitutionKey(substitutor, method) + ":" + substitutionKey(substitutor, method.getContainingClass()); + var cached = symbols.get(key); + if (cached == null) { + cached = new JMethodSymbol(this, method, substitutor, null, key); + symbols.put(key, cached); } + return (JMethodSymbol) cached; } - @Override - public Type getClassType(String fullyQualifiedName) { - Type cached = nameToTypeCache.get(fullyQualifiedName); - if (cached != null) { - return cached; - } - return nameToTypeCache.computeIfAbsent(fullyQualifiedName, t -> { - ITypeBinding typeBinding = resolveType(t); - return typeBinding != null ? type(typeBinding) : Type.UNKNOWN; - }); + private PsiSubstitutor completeSubstitutor(PsiSubstitutor substitutor, PsiTypeParameterListOwner owner) { + var factory = JavaPsiFacade.getElementFactory(project); + for (var parameter : owner.getTypeParameters()) { + if (!substitutor.getSubstitutionMap().containsKey(parameter)) { + substitutor = substitutor.put(parameter, factory.createType(parameter)); + } + } + var parent = owner instanceof PsiMethod method ? method.getContainingClass() : ((PsiClass) owner).getContainingClass(); + return parent == null ? substitutor : completeSubstitutor(substitutor, parent); } - @Nullable - ITypeBinding resolveType(String name) { - int dimensions = 0; - int end = name.length() - 1; - while (name.charAt(end) == ']') { - end -= 2; - dimensions++; + Symbol.MethodSymbol lambda(PsiLambdaExpression lambda) { + String key = "lambda:" + key(lambda); + var cached = symbols.get(key); + if (cached == null) { + var method = LambdaUtil.getFunctionalInterfaceMethod(lambda); + if (method == null) { + return Symbol.MethodSymbol.UNKNOWN_METHOD; + } + var functionalType = LambdaUtil.normalizeFunctionalType(lambda.getFunctionalInterfaceType()); + var substitutor = LambdaUtil.getSubstitutor(method, ((PsiClassType) functionalType).resolveGenerics()); + cached = new JMethodSymbol(this, method, substitutor, lambda, key); + symbols.put(key, cached); } - name = name.substring(0, end + 1); + return (Symbol.MethodSymbol) cached; + } - ITypeBinding typeBinding = ast.resolveWellKnownType(name); - if (typeBinding == null) { - typeBinding = ASTUtils.resolveType(ast, name); - if (typeBinding == null) { - return null; + Symbol owner(PsiElement element) { + for (var parent = element.getParent(); parent != null; parent = parent.getParent()) { + if (parent instanceof PsiLambdaExpression lambda) { + return lambda(lambda); + } + if (parent instanceof PsiMethod || parent instanceof PsiClass) { + return symbol(parent); + } + if (parent instanceof PsiClassInitializer initializer) { + var cls = (Symbol.TypeSymbol) symbol(initializer.getContainingClass()); + boolean isStatic = initializer.hasModifierProperty(PsiModifier.STATIC); + return initializer(cls, isStatic); + } + if (parent instanceof PsiJavaFile javaFile) { + return symbol(JavaPsiFacade.getInstance(project).findPackage(javaFile.getPackageName())); } } - return dimensions == 0 ? typeBinding : typeBinding.createArrayType(dimensions); + return Symbol.ROOT_PACKAGE; } - IAnnotationBinding[] resolvePackageAnnotations(String packageName) { - return ASTUtils.resolvePackageAnnotations(ast, packageName); + JInitializerBlockSymbol initializer(Symbol.TypeSymbol owner, boolean isStatic) { + return initializers.computeIfAbsent(((JSymbol) owner).key + isStatic, unused -> new JInitializerBlockSymbol(owner, isStatic)); } - @Override - public Runnable getEnvironmentCleaner() { - if (environmentCleaner == null) { - environmentCleaner = FrontendResources.idempotent(ASTUtils.getEnvironmentCleaner(ast)); + String binaryName(PsiClass cls) { + if (cls.getContainingClass() != null) { + return binaryName(cls.getContainingClass()) + "$" + cls.getName(); } - return environmentCleaner; + if (cls.getQualifiedName() != null) { + return cls.getQualifiedName(); + } + var outer = PsiTreeUtil.getParentOfType(cls, PsiClass.class, true); + if (outer == null) { + return cls.getName() == null ? "" : cls.getName(); + } + int ordinal = 0; + for (var candidate : PsiTreeUtil.findChildrenOfType(outer, PsiClass.class)) { + if (candidate instanceof PsiAnonymousClass || candidate.getQualifiedName() == null) { + ordinal++; + } + if (candidate == cls) { + break; + } + } + return binaryName(outer) + "$" + ordinal + (cls.getName() == null ? "" : cls.getName()); } - } diff --git a/java-frontend/src/main/java/org/sonar/java/model/JSymbol.java b/java-frontend/src/main/java/org/sonar/java/model/JSymbol.java index 3d0425a6c45..b834653e8fe 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/JSymbol.java +++ b/java-frontend/src/main/java/org/sonar/java/model/JSymbol.java @@ -16,16 +16,16 @@ */ package org.sonar.java.model; -import java.util.Arrays; -import java.util.Collections; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiDocCommentOwner; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiEnumConstant; +import com.intellij.psi.PsiModifier; +import com.intellij.psi.PsiModifierListOwner; +import com.intellij.psi.PsiNamedElement; +import com.intellij.psi.PsiPackage; +import com.intellij.psi.util.PsiTreeUtil; import java.util.List; -import java.util.Objects; -import javax.annotation.Nullable; -import org.eclipse.jdt.core.dom.IBinding; -import org.eclipse.jdt.core.dom.IMethodBinding; -import org.eclipse.jdt.core.dom.ITypeBinding; -import org.eclipse.jdt.core.dom.IVariableBinding; -import org.eclipse.jdt.core.dom.Modifier; import org.sonar.plugins.java.api.semantic.Symbol; import org.sonar.plugins.java.api.semantic.SymbolMetadata; import org.sonar.plugins.java.api.semantic.Type; @@ -33,450 +33,157 @@ import org.sonar.plugins.java.api.tree.Tree; abstract class JSymbol implements Symbol { - - protected final JSema sema; - protected final IBinding binding; - - /** - * Cache for {@link #hashCode()}. - */ - private int hashCode; - - /** - * Cache for {@link #owner()}. - */ - private Symbol owner; - - /** - * Cache for {@link #metadata()}. - */ + final JSema sema; + final PsiElement element; + final String key; private SymbolMetadata metadata; - JSymbol(JSema sema, IBinding binding) { - this.sema = Objects.requireNonNull(sema); - this.binding = Objects.requireNonNull(binding); - } - - @Override - public final boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (!(obj instanceof JSymbol)) { - return false; - } - JSymbol other = (JSymbol) obj; - if (this.binding.getKind() != other.binding.getKind()) { - return false; - } - switch (this.binding.getKind()) { - case IBinding.TYPE: - return JType.areEqual( - (ITypeBinding) this.binding, - (ITypeBinding) other.binding - ); - case IBinding.VARIABLE: - return areEqualVariables( - this, - other - ); - case IBinding.METHOD: - return areEqualMethodSymbols((JMethodSymbol) this, (JMethodSymbol) other); - default: - return super.equals(obj); - } + JSymbol(JSema sema, PsiElement element, String key) { + this.sema = sema; + this.element = element; + this.key = key; } - private static boolean areEqualVariables(JSymbol thisVariableSymbol, JSymbol otherVariableSymbol) { - IVariableBinding thisBinding = (IVariableBinding) thisVariableSymbol.binding; - IVariableBinding otherBinding = (IVariableBinding) otherVariableSymbol.binding; - return thisBinding.getVariableId() == otherBinding.getVariableId() - && thisVariableSymbol.owner().equals(otherVariableSymbol.owner()); - } - - /** - * Method symbols are considered equal if they have the same name, same owner, same parameter types, same type parameters and same type arguments. - * In this example: - *
-   * {@code   boolean foo(T t, String s);
-   *  foo(43, "bar");}
-   * 
- * The first symbol {@code foo} has type parameter {@code T}, parameter types {@code T} and {@code String}, and no type arguments. - * The symbol {@code foo} on the second line has no type parameter, parameter types are {@code Integer} and {@code String}, and has type argument {@code Integer}. - * So the two {@code foo} symbols are not equal, although they may refer to the same method. - */ - private static boolean areEqualMethodSymbols(JMethodSymbol thisMethodSymbol, JMethodSymbol otherMethodSymbol) { - IMethodBinding thisBinding = (IMethodBinding) thisMethodSymbol.binding; - IMethodBinding otherBinding = (IMethodBinding) otherMethodSymbol.binding; - // In the case of lambdas, ecj doesn't assign a name to the different symbols, unlike the Java compiler. - // We work around that by comparing keys provided by ecj. - if (thisMethodSymbol.isLambda() && otherMethodSymbol.isLambda()) { - return Objects.equals(thisBinding.getKey(), otherBinding.getKey()); - } - return thisMethodSymbol.name().equals(otherMethodSymbol.name()) - && thisMethodSymbol.owner().equals(otherMethodSymbol.owner()) - && Arrays.equals(thisBinding.getParameterTypes(), otherBinding.getParameterTypes()) - && Arrays.equals(thisBinding.getTypeParameters(), otherBinding.getTypeParameters()) - && Arrays.equals(thisBinding.getTypeArguments(), otherBinding.getTypeArguments()); + boolean modifier(String name) { + return sema.read(() -> element instanceof PsiModifierListOwner owner && owner.hasModifierProperty(name)); } @Override - public final int hashCode() { - if (hashCode == 0) { - Symbol resolvedOwner = owner(); - hashCode = resolvedOwner == null ? 0 : (resolvedOwner.hashCode() * 31); - hashCode += name().hashCode(); - } - return hashCode; + public String name() { + return sema.read(() -> element instanceof PsiNamedElement named ? named.getName() : ""); } - /** - * @see JType#name() - */ @Override - public final String name() { - if (binding.getKind() == IBinding.METHOD && ((IMethodBinding) binding).isConstructor()) { - return ""; - } - if (binding.getKind() == IBinding.TYPE && ((ITypeBinding) binding).isParameterizedType()) { - // without names of parameters - return ((ITypeBinding) binding).getErasure().getName(); - } - return binding.getName(); + public Symbol owner() { + return sema.read(() -> sema.owner(element)); } - /** - * @see #enclosingClass() - */ @Override - public final Symbol owner() { - if (isUnknown()) { - return Symbol.UNKNOWN_SYMBOL; - } - if (owner == null) { - owner = convertOwner(); - } - return owner; - } - - private Symbol convertOwner() { - switch (binding.getKind()) { - case IBinding.PACKAGE: - return Symbol.ROOT_PACKAGE; - case IBinding.TYPE: - return typeOwner((ITypeBinding) binding); - case IBinding.METHOD: - return methodOwner((IMethodBinding) binding); - case IBinding.VARIABLE: - return variableOwner((IVariableBinding) binding); - default: - throw new IllegalStateException(unexpectedBinding()); - } - } - - private String unexpectedBinding() { - return "Unexpected binding Kind: " + binding.getKind(); - } - - private Symbol typeOwner(ITypeBinding typeBinding) { - if (typeBinding.isPrimitive()) { - return Symbol.ROOT_PACKAGE; - } - IMethodBinding declaringMethod = typeBinding.getDeclaringMethod(); - if (declaringMethod != null) { - // local type - return sema.methodSymbol(declaringMethod); - } - ITypeBinding declaringClass = typeBinding.getDeclaringClass(); - if (declaringClass != null) { - // member type - return sema.typeSymbol(declaringClass); - } - // top-level type - return sema.packageSymbol(typeBinding.getPackage()); - } - - private Symbol methodOwner(IMethodBinding methodBinding) { - return sema.typeSymbol(methodBinding.getDeclaringClass()); - } - - private Symbol variableOwner(IVariableBinding variableBinding) { - if (!variableBinding.isRecordComponent()) { - IMethodBinding declaringMethod = variableBinding.getDeclaringMethod(); - if (declaringMethod != null) { - return sema.methodSymbol(declaringMethod); - } - ITypeBinding declaringClass = variableBinding.getDeclaringClass(); - if (declaringClass != null) { - // field - return sema.typeSymbol(declaringClass); - } - } - return ownerOfRecordComponentConstant(variableBinding); - } - - private Symbol ownerOfRecordComponentConstant(IVariableBinding variableBinding) { - Tree node = sema.declarations.get(variableBinding); - if (node == null) { - // array.length - return Symbol.UNKNOWN_SYMBOL; - } - boolean initializerBlock = false; - boolean staticInitializerBlock = false; - while (true) { - node = node.parent(); - switch (node.kind()) { - case CLASS, - RECORD, - ENUM: - JTypeSymbol typeSymbol = sema.typeSymbol(EcjTreeBindings.typeBinding(node)); - if (initializerBlock) { - return sema.initializerBlockSymbol(typeSymbol); - } - if (staticInitializerBlock) { - return sema.staticInitializerBlockSymbol(typeSymbol); - } - // Record parameters - return typeSymbol; - case INITIALIZER: - initializerBlock = true; - break; - case STATIC_INITIALIZER: - staticInitializerBlock = true; - break; - case METHOD, - CONSTRUCTOR: - // local variable declaration in recovered method - // and recovered methods do not have bindings - return MethodSymbol.UNKNOWN_METHOD; - default: - // continue exploring parent - break; - } - } - } - - @Override - public final Type type() { - switch (binding.getKind()) { - case IBinding.TYPE: - return sema.type((ITypeBinding) binding); - case IBinding.VARIABLE: - ITypeBinding variableType = ((IVariableBinding) binding).getType(); - return variableType != null ? sema.type(variableType) : Type.UNKNOWN; - case IBinding.PACKAGE, - IBinding.METHOD: - return Type.UNKNOWN; - default: - throw new IllegalStateException(unexpectedBinding()); - } + public Type type() { + return Type.UNKNOWN; } @Override - public final boolean isVariableSymbol() { - return binding.getKind() == IBinding.VARIABLE; + public boolean isVariableSymbol() { + return this instanceof Symbol.VariableSymbol; } @Override - public final boolean isTypeSymbol() { - return !isUnknown() && binding.getKind() == IBinding.TYPE; + public boolean isTypeSymbol() { + return this instanceof Symbol.TypeSymbol && !isUnknown(); } @Override - public final boolean isMethodSymbol() { - return binding.getKind() == IBinding.METHOD; + public boolean isMethodSymbol() { + return this instanceof Symbol.MethodSymbol; } @Override - public final boolean isPackageSymbol() { - return binding.getKind() == IBinding.PACKAGE; + public boolean isPackageSymbol() { + return element instanceof PsiPackage; } @Override - public final boolean isStatic() { - return Modifier.isStatic(binding.getModifiers()); + public boolean isStatic() { + return modifier(PsiModifier.STATIC); } @Override - public final boolean isFinal() { - return Modifier.isFinal(binding.getModifiers()); + public boolean isFinal() { + return modifier(PsiModifier.FINAL); } @Override - public final boolean isEnum() { - switch (binding.getKind()) { - case IBinding.TYPE: - return ((ITypeBinding) binding).isEnum(); - case IBinding.VARIABLE: - return ((IVariableBinding) binding).isEnumConstant(); - default: - return false; - } + public boolean isEnum() { + return sema.read(() -> element instanceof PsiClass cls && cls.isEnum() || element instanceof PsiEnumConstant); } @Override - public final boolean isInterface() { - return binding.getKind() == IBinding.TYPE - && ((ITypeBinding) binding).isInterface(); + public boolean isInterface() { + return sema.read(() -> element instanceof PsiClass cls && cls.isInterface() && !cls.isAnnotationType()); } @Override - public final boolean isAbstract() { - return Modifier.isAbstract(binding.getModifiers()); + public boolean isAbstract() { + return modifier(PsiModifier.ABSTRACT); } @Override - public final boolean isPublic() { - return Modifier.isPublic(binding.getModifiers()); + public boolean isPublic() { + return modifier(PsiModifier.PUBLIC); } @Override - public final boolean isPrivate() { - return Modifier.isPrivate(binding.getModifiers()); + public boolean isPrivate() { + return modifier(PsiModifier.PRIVATE); } @Override - public final boolean isProtected() { - return Modifier.isProtected(binding.getModifiers()); + public boolean isProtected() { + return modifier(PsiModifier.PROTECTED); } @Override - public final boolean isPackageVisibility() { + public boolean isPackageVisibility() { return !isPublic() && !isPrivate() && !isProtected(); } - @Override - public final boolean isDeprecated() { - return binding.isDeprecated(); + @Override public boolean isDeprecated() { + return sema.read(() -> element instanceof PsiModifierListOwner owner && owner.getModifierList() != null + && owner.getModifierList().findAnnotation("java.lang.Deprecated") != null + || element instanceof PsiDocCommentOwner documented && documented.getDocComment() != null && documented.getDocComment().findTagByName("deprecated") != null); } @Override - public final boolean isVolatile() { - return Modifier.isVolatile(binding.getModifiers()); + public boolean isVolatile() { + return modifier(PsiModifier.VOLATILE); } @Override - public final boolean isUnknown() { - return binding.isRecovered(); + public boolean isUnknown() { + return false; } @Override - public final SymbolMetadata metadata() { - if (metadata == null) { - try { - metadata = convertMetadata(); - } catch (RuntimeException e) { - // ECJ raises exception in rare occasions, when it is the case, we don't want to prevent the whole analysis of the file - // ECJ 3.41.0: no longer throws the exception on the code that was used in the test - metadata = Symbols.EMPTY_METADATA; + public SymbolMetadata metadata() { + return sema.read(() -> { + if (metadata == null) { + metadata = JSymbolMetadata.of(sema, this, element); } - } - return metadata; - } - - private SymbolMetadata convertMetadata() { - switch (binding.getKind()) { - case IBinding.PACKAGE: - return EcjSymbolMetadata.declaration(sema, this, sema.resolvePackageAnnotations(binding.getName())); - case IBinding.VARIABLE: - ITypeBinding type = ((IVariableBinding) binding).getType(); - if (type == null) { - return EcjSymbolMetadata.declaration(sema, this, binding.getAnnotations()); - } - return convertMetadata(type); - case IBinding.METHOD: - ITypeBinding returnType = ((IMethodBinding) binding).getReturnType(); - // In rare circumstances, when the semantic information is incomplete, returnType can be null. - if (returnType == null) { - return Symbols.EMPTY_METADATA; - } - return convertMetadata(returnType); - default: - return EcjSymbolMetadata.declaration(sema, this, binding.getAnnotations()); - } + return metadata; + }); } - private SymbolMetadata convertMetadata(ITypeBinding type) { - return EcjSymbolMetadata.of(sema, this, type, binding.getAnnotations()); - } - - /** - * @see #owner() - */ - @Nullable @Override - public final TypeSymbol enclosingClass() { - switch (binding.getKind()) { - case IBinding.PACKAGE: - return null; - case IBinding.TYPE: - return typeEnclosingClass((ITypeBinding) binding); - case IBinding.METHOD: - return methodEnclosingClass((IMethodBinding) binding); - case IBinding.VARIABLE: - return variableEnclosingClass((IVariableBinding) binding); - default: - throw new IllegalStateException(unexpectedBinding()); - } + public TypeSymbol enclosingClass() { + return sema.read(() -> { + var cls = element instanceof PsiClass c ? c : PsiTreeUtil.getParentOfType(element, PsiClass.class); + return cls == null ? null : (TypeSymbol) sema.symbol(cls); + }); } - private TypeSymbol typeEnclosingClass(ITypeBinding typeBinding) { - ITypeBinding declaringClass = typeBinding.getDeclaringClass(); - if (declaringClass != null) { - // nested (member or local) type - return sema.typeSymbol(declaringClass); - } - // top-level type - return (TypeSymbol) this; + @Override + public List usages() { + return sema.read(() -> sema.usages.getOrDefault(sema.key(element), List.of())); } - private TypeSymbol methodEnclosingClass(IMethodBinding methodBinding) { - ITypeBinding declaringClass = methodBinding.getDeclaringClass(); - return sema.typeSymbol(declaringClass); + @Override + public Tree declaration() { + return sema.read(() -> sema.declarations.get(sema.key(element))); } - private TypeSymbol variableEnclosingClass(IVariableBinding variableBinding) { - ITypeBinding declaringClass = variableBinding.getDeclaringClass(); - if (declaringClass != null) { - // field - return sema.typeSymbol(declaringClass); - } - IMethodBinding declaringMethod = variableBinding.getDeclaringMethod(); - if (declaringMethod != null) { - // local variable - return sema.typeSymbol(declaringMethod.getDeclaringClass()); - } - Tree node = sema.declarations.get(variableBinding); - if (node == null) { - // array.length - return TypeSymbol.UNKNOWN_TYPE; - } - do { - node = node.parent(); - switch (node.kind()) { - case CLASS, - RECORD, - ENUM: - // variable declaration in a static or instance initializer - // or local variable declaration in recovered method - return sema.typeSymbol(EcjTreeBindings.typeBinding(node)); - default: - // continue exploring parent - break; - } - } while (true); + @Override + public boolean equals(Object other) { + return other instanceof JSymbol symbol && getClass() == symbol.getClass() && key.equals(symbol.key); } @Override - public final List usages() { - List usages = sema.usages.get(JSema.declarationBinding(binding)); - return usages != null ? usages : Collections.emptyList(); + public int hashCode() { + return key.hashCode(); } - @Nullable @Override - public Tree declaration() { - return sema.declarations.get(JSema.declarationBinding(binding)); + public String toString() { + return name(); } - } diff --git a/java-frontend/src/main/java/org/sonar/java/model/JSymbolMetadata.java b/java-frontend/src/main/java/org/sonar/java/model/JSymbolMetadata.java index 422a97356e5..3a2b2ce2322 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/JSymbolMetadata.java +++ b/java-frontend/src/main/java/org/sonar/java/model/JSymbolMetadata.java @@ -16,6 +16,25 @@ */ package org.sonar.java.model; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiAnnotation; +import com.intellij.psi.PsiAnnotationMemberValue; +import com.intellij.psi.PsiArrayInitializerMemberValue; +import com.intellij.psi.PsiArrayType; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiClassObjectAccessExpression; +import com.intellij.psi.PsiClassType; +import com.intellij.psi.PsiCompiledElement; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiEnumConstant; +import com.intellij.psi.PsiJavaFile; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiModifierListOwner; +import com.intellij.psi.PsiPackage; +import com.intellij.psi.PsiReferenceExpression; +import com.intellij.psi.PsiVariable; +import com.intellij.psi.impl.file.impl.JavaFileManager; +import com.intellij.psi.search.GlobalSearchScope; import java.util.ArrayList; import java.util.Arrays; import java.util.EnumMap; @@ -338,4 +357,94 @@ public Tree declaration() { } } + static JSymbolMetadata of(JSema sema, Symbol owner, PsiElement element) { + var annotations = element instanceof PsiPackage pkg ? packageAnnotations(sema, pkg) + : element instanceof PsiModifierListOwner declaration ? declaration.getAnnotations() : new PsiAnnotation[0]; + com.intellij.psi.PsiType type = element instanceof PsiVariable variable ? variable.getType() + : element instanceof PsiMethod method ? method.getReturnType() : null; + if (type != null) { + type = owner instanceof JMethodSymbol method ? method.substitutor.substitute(type) + : owner instanceof JVariableSymbol variable ? variable.substitutor.substitute(type) : type; + } + return metadata(sema, owner, annotations, type, false); + } + + private static PsiAnnotation[] packageAnnotations(JSema sema, PsiPackage pkg) { + var name = pkg.getQualifiedName(); + var classes = JavaFileManager.getInstance(sema.project).findClasses(name.isEmpty() ? "package-info" : name + ".package-info", + GlobalSearchScope.allScope(sema.project)); + var binary = Arrays.stream(classes).filter(PsiCompiledElement.class::isInstance).findFirst().orElse(null); + var statement = binary == null ? null : ((PsiJavaFile) binary.getContainingFile()).getPackageStatement(); + return statement == null || statement.getAnnotationList() == null ? new PsiAnnotation[0] : statement.getAnnotationList().getAnnotations(); + } + + private static JSymbolMetadata metadata(JSema sema, Symbol owner, PsiAnnotation[] declarations, com.intellij.psi.PsiType type, boolean argument) { + List annotations = new ArrayList<>(Arrays.asList(declarations)); + if (type != null) { + for (var annotation : type.getAnnotations()) { + if (!annotations.contains(annotation)) { + annotations.add(annotation); + } + } + } + var parameters = type instanceof PsiClassType cls ? Arrays.stream(cls.getParameters()) + .map(t -> metadata(sema, owner, new PsiAnnotation[0], t, true)).toArray(JSymbolMetadata[]::new) : new JSymbolMetadata[0]; + return new JSymbolMetadata(owner, () -> sema.read(() -> annotations.stream() + .filter(a -> a.getNameReferenceElement() == null || !(a.getNameReferenceElement().resolve() instanceof PsiClass cls) || cls.isAnnotationType()) + .map(a -> (SymbolMetadata.AnnotationInstance) new Annotation(sema, a)).toList()), parameters, argument); + } + + static Object value(JSema sema, PsiAnnotationMemberValue value) { + if (value instanceof PsiAnnotation annotation) { + return new Annotation(sema, annotation); + } + if (value instanceof PsiArrayInitializerMemberValue array) { + return Arrays.stream(array.getInitializers()).map(v -> value(sema, v)).toArray(); + } + if (value instanceof PsiClassObjectAccessExpression cls) { + return sema.type(cls.getOperand().getType()).symbol(); + } + if (value instanceof PsiReferenceExpression reference && reference.resolve() instanceof PsiEnumConstant constant) { + return sema.symbol(constant); + } + return value == null ? null : JavaPsiFacade.getInstance(sema.project).getConstantEvaluationHelper().computeConstantExpression(value); + } + + static Object value(JSema sema, PsiAnnotationMemberValue value, com.intellij.psi.PsiType expectedType) { + var result = value(sema, value); + return result != null && expectedType instanceof PsiArrayType && !(result instanceof Object[]) ? new Object[] {result} : result; + } + + private static final class Annotation implements SymbolMetadata.AnnotationInstance { + private final JSema sema; + private final PsiAnnotation annotation; + + Annotation(JSema sema, PsiAnnotation annotation) { + this.sema = sema; + this.annotation = annotation; + } + + @Override + public Symbol symbol() { + return sema.read(() -> { + var cls = annotation.resolveAnnotationType(); + return cls == null ? annotation.getNameReferenceElement() == null ? Symbol.UNKNOWN_SYMBOL + : sema.type(JavaPsiFacade.getElementFactory(sema.project).createTypeByFQClassName(annotation.getQualifiedName(), annotation.getResolveScope())).symbol() + : sema.symbol(cls); + }); + } + + @Override + public List values() { + return sema.read(() -> { + var declaration = annotation.resolveAnnotationType(); + return Arrays.stream(annotation.getParameterList().getAttributes()).map(attribute -> { + var name = attribute.getName() == null ? "value" : attribute.getName(); + var methods = declaration == null ? new PsiMethod[0] : declaration.findMethodsByName(name, false); + var expectedType = methods.length == 0 ? null : methods[0].getReturnType(); + return (SymbolMetadata.AnnotationValue) new AnnotationValueImpl(name, value(sema, attribute.getValue(), expectedType)); + }).toList(); + }); + } + } } diff --git a/java-frontend/src/main/java/org/sonar/java/model/JType.java b/java-frontend/src/main/java/org/sonar/java/model/JType.java index caa8ba3daa0..cb58fd3dba6 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/JType.java +++ b/java-frontend/src/main/java/org/sonar/java/model/JType.java @@ -16,366 +16,291 @@ */ package org.sonar.java.model; +import com.intellij.psi.PsiArrayType; +import com.intellij.psi.PsiCapturedWildcardType; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiClassType; +import com.intellij.psi.PsiIntersectionType; +import com.intellij.psi.PsiPrimitiveType; +import com.intellij.psi.PsiReferenceList; +import com.intellij.psi.impl.source.PsiClassReferenceType; +import com.intellij.psi.PsiTypeParameter; +import com.intellij.psi.PsiTypes; +import com.intellij.psi.PsiWildcardType; +import com.intellij.psi.util.TypeConversionUtil; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Locale; -import java.util.Objects; import java.util.Set; import java.util.TreeSet; -import javax.annotation.Nullable; -import org.eclipse.jdt.core.dom.ITypeBinding; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.stream.IntStream; import org.sonar.plugins.java.api.semantic.Symbol; import org.sonar.plugins.java.api.semantic.Type; final class JType implements Type, Type.ArrayType { - - private static final Logger LOG = LoggerFactory.getLogger(JType.class); - final JSema sema; - final ITypeBinding typeBinding; - - private final String fullyQualifiedName; - - /** - * Cache for {@link #primitiveWrapperType()}. - */ - private Type primitiveWrapperType; + final com.intellij.psi.PsiType psi; + final String key; - /** - * Cache for {@link #primitiveType()}. - */ - private Type primitiveType; - - /** - * Cache for {@link #declaringType()}. - */ - private Type declaringType; - - /** - * Cache for {@link #typeArguments()}. - */ - private List typeArguments; + JType(JSema sema, com.intellij.psi.PsiType psi, String key) { + this.sema = sema; + this.psi = psi; + this.key = key; + } - JType(JSema sema, ITypeBinding typeBinding) { - this.sema = Objects.requireNonNull(sema); - this.typeBinding = Objects.requireNonNull(typeBinding); - this.fullyQualifiedName = fullyQualifiedName(typeBinding); + PsiClass resolvedClass() { + return psi instanceof PsiClassType cls ? cls.resolve() : null; } @Override public Set directSuperTypes() { - Set result = new HashSet<>(); - ITypeBinding superclass = typeBinding.getSuperclass(); - if (superclass != null) { - result.add(sema.type(superclass)); - } - Arrays.stream(typeBinding.getInterfaces()) - .map(sema::type) - .forEach(result::add); - return result; + return sema.read(() -> { + Set result = new HashSet<>(); + if (!isUnknown()) { + for (var parent : psi.getSuperTypes()) { + if (!(resolvedClass() != null && resolvedClass().isInterface() && parent.equalsToText("java.lang.Object"))) { + result.add(sema.type(parent)); + } + } + } + return result; + }); } @Override - public boolean is(String fullyQualifiedName) { - return fullyQualifiedName.equals(this.fullyQualifiedName()); + public boolean is(String name) { + return fullyQualifiedName().equals(name); } @Override - public boolean isSubtypeOf(String fullyQualifiedName) { - return isSubtypeOf(sema.getClassType(fullyQualifiedName)); + public boolean isSubtypeOf(String name) { + return isSubtypeOf(sema.getClassType(name).erasure()); } @Override - public boolean isSubtypeOf(Type superType) { - return !superType.isUnknown() - && isSubtype(this.typeBinding, ((JType) superType).typeBinding); - } - - private static boolean isSubtype(ITypeBinding left, ITypeBinding right) { - if (left.isRecovered()) { - return false; - } - if (left.isNullType()) { - return !right.isPrimitive(); - } - try { - return left.isSubTypeCompatible(right); - } catch (NullPointerException ex) { - // In rare circumstances, ECJ may produce a NPE while calling isSubTypeCompatible(), see SONARJAVA-4390 - LOG.debug("NullPointerException while resolving isSubTypeCompatible()", ex); - return false; - } + public boolean isSubtypeOf(Type other) { + return sema.read(() -> { + if (!(other instanceof JType target) || isUnknown() || target.isUnknown()) { + return false; + } + if (isNullType()) { + return !target.isPrimitive() && !target.isVoid(); + } + if (isPrimitive() || target.isPrimitive() || isVoid() || target.isVoid()) { + return equals(target); + } + try { + return TypeConversionUtil.isAssignable(target.psi, psi, false); + } catch (NullPointerException e) { + org.slf4j.LoggerFactory.getLogger(JType.class).debug("NullPointerException while resolving isSubTypeCompatible()"); + return false; + } + }); } @Override public boolean isArray() { - return typeBinding.isArray(); - } - - @Override - public boolean isClass() { - return typeBinding.isClass() - || typeBinding.isInterface() - || typeBinding.isEnum(); + return psi instanceof PsiArrayType; } @Override public boolean isVoid() { - return "void".equals(fullyQualifiedName()); + return PsiTypes.voidType().equals(psi); } @Override public boolean isPrimitive() { - return typeBinding.isPrimitive() - && !isVoid(); + return psi instanceof PsiPrimitiveType && !isVoid() && !isNullType(); } @Override public boolean isPrimitive(Primitives primitive) { - // TODO suboptimal - return primitive.name().toLowerCase(Locale.ROOT).equals(fullyQualifiedName()); + return is(primitive.name().toLowerCase(Locale.ROOT)); + } + + @Override + public boolean isNullType() { + return PsiTypes.nullType().equals(psi); } @Override public boolean isPrimitiveWrapper() { - return isClass() && JUtils.WRAPPER_TO_PRIMITIVE.containsKey(fullyQualifiedName()); + return JUtils.WRAPPER_TO_PRIMITIVE.containsKey(fullyQualifiedName()); } - @Nullable @Override - public Type primitiveWrapperType() { - if (primitiveWrapperType == null) { - String name = JUtils.PRIMITIVE_TO_WRAPPER.get(fullyQualifiedName()); - if (name == null) { - return null; - } - ITypeBinding resolvedType = sema.resolveType(name); - if (resolvedType == null) { - return null; - } - primitiveWrapperType = sema.type(resolvedType); - } - return primitiveWrapperType; + public boolean isNumerical() { + return Set.of("byte", "char", "short", "int", "long", "float", "double").contains(fullyQualifiedName()); } - @Nullable @Override - public Type primitiveType() { - if (primitiveType == null) { - String name = JUtils.WRAPPER_TO_PRIMITIVE.get(fullyQualifiedName()); - if (name == null) { - return null; - } - ITypeBinding resolvedType = sema.resolveType(name); - if (resolvedType == null) { - return null; - } - primitiveType = sema.type(resolvedType); - } - return primitiveType; + public boolean isIntersectionType() { + return psi instanceof PsiIntersectionType; } @Override - public boolean isNullType() { - return !isUnknown() && typeBinding.isNullType(); + public boolean isClass() { + return sema.read(() -> psi instanceof PsiClassType && !(resolvedClass() instanceof PsiTypeParameter)); } @Override public boolean isTypeVar() { - return !isUnknown() && typeBinding.isTypeVariable(); + return sema.read(() -> resolvedClass() instanceof PsiTypeParameter); } @Override public boolean isRawType() { - if (isUnknown()) { - return false; - } - return typeBinding.isRawType(); + return sema.read(() -> psi instanceof PsiClassType cls && cls.isRaw()); } @Override - public Type declaringType() { - if (declaringType == null) { - if (isUnknown()) { - return this; - } - declaringType = sema.type(typeBinding.getTypeDeclaration()); + public boolean isUnknown() { + return sema.read(() -> unresolved(psi)); + } + + private static boolean unresolved(com.intellij.psi.PsiType type) { + if (type instanceof PsiArrayType array) { + return unresolved(array.getComponentType()); + } + if (type instanceof PsiWildcardType wildcard && wildcard.getBound() != null) { + return unresolved(wildcard.getBound()); } - return declaringType; + return type instanceof PsiClassType cls && (cls.resolve() == null || Arrays.stream(cls.getParameters()).anyMatch(JType::unresolved)); } @Override - public boolean isUnknown() { - return typeBinding.isRecovered(); + public Type primitiveWrapperType() { + String name = JUtils.PRIMITIVE_TO_WRAPPER.get(fullyQualifiedName()); + Type value = name == null ? null : sema.getClassType(name); + return value == Type.UNKNOWN ? null : value; } @Override - public boolean isNumerical() { - switch (fullyQualifiedName()) { - case "byte", - "char", - "short", - "int", - "long", - "float", - "double": - return true; - default: - return false; - } + public Type primitiveType() { + String name = JUtils.WRAPPER_TO_PRIMITIVE.get(fullyQualifiedName()); + Type value = name == null ? null : sema.getClassType(name); + return value == Type.UNKNOWN ? null : value; } @Override - public String fullyQualifiedName() { - return fullyQualifiedName; - } - - private static String fullyQualifiedName(ITypeBinding typeBinding) { - String qualifiedName; - if (typeBinding.isNullType()) { - qualifiedName = ""; - } else if (typeBinding.isPrimitive()) { - qualifiedName = typeBinding.getName(); - } else if (typeBinding.isArray()) { - qualifiedName = fullyQualifiedName(typeBinding.getComponentType()) + "[]"; - } else if (typeBinding.isCapture()) { - qualifiedName = "!capture!"; - } else if (typeBinding.isTypeVariable()) { - qualifiedName = typeBinding.getName(); - } else { - qualifiedName = typeBinding.getBinaryName(); - if (qualifiedName == null) { - // e.g. anonymous class in unreachable code - qualifiedName = typeBinding.getKey(); - } - } - if (typeBinding.isIntersectionType()) { - TreeSet intersectionTypes = new TreeSet<>(); - intersectionTypes.add(qualifiedName); - for (ITypeBinding typeBound : typeBinding.getTypeBounds()) { - intersectionTypes.add(fullyQualifiedName(typeBound)); - } - qualifiedName = String.join(" & ", intersectionTypes); - } - return qualifiedName; + public Type declaringType() { + return sema.read(() -> { + var cls = resolvedClass(); + return cls == null ? this : sema.type(sema.declarationType(cls)); + }); } @Override - public boolean isIntersectionType() { - return typeBinding.isIntersectionType(); + public String fullyQualifiedName() { + return sema.read(() -> qualifiedName(psi)); } - @Override - public Type[] getIntersectionTypes() { - if (!isIntersectionType()) { - return new Type[] { this }; + private String qualifiedName(com.intellij.psi.PsiType type) { + if (type instanceof PsiArrayType array) { + return qualifiedName(array.getComponentType()) + "[]"; } - ITypeBinding[] bounds = typeBinding.getTypeBounds(); - Type[] types = new Type[bounds.length]; - for (int i = 0; i < bounds.length; i++) { - types[i] = sema.type(bounds[i]); + if (type instanceof PsiCapturedWildcardType) { + return "!capture!"; } - return types; - } - - /** - * @see JSymbol#name() - */ - @Override - public String name() { - if (typeBinding.isNullType()) { - return ""; - } else if (typeBinding.isParameterizedType()) { - // without names of parameters - return typeBinding.getErasure().getName(); + if (type instanceof PsiWildcardType wildcard) { + return wildcard.getCanonicalText(false); + } + if (type instanceof PsiIntersectionType intersection) { + Set names = new TreeSet<>(); + Arrays.stream(intersection.getConjuncts()).map(this::qualifiedName).forEach(names::add); + return String.join(" & ", names); + } + if (type instanceof PsiClassType cls) { + var resolved = cls.resolve(); + if (resolved instanceof PsiTypeParameter parameter) { + return parameter.getName(); + } + if (resolved != null) { + return sema.binaryName(resolved); + } + String name = cls.rawType().getCanonicalText(false); + return (cls instanceof PsiClassReferenceType reference && reference.getReference().getParent() instanceof PsiReferenceList) + || sema.explicitRuntime || sema.getClassType("java.lang.Object").isUnknown() ? "Recovered#typeBindingL" + name.replace('.', '/') + ";0" : name; } - return typeBinding.getName(); + return PsiTypes.nullType().equals(type) ? "" : type.getCanonicalText(false); } @Override - public String toString() { - return name(); + public String name() { + return sema.read(() -> { + if (psi instanceof PsiArrayType array) { + return sema.type(array.getComponentType()).name() + "[]"; + } + var cls = resolvedClass(); + if (cls != null) { + return cls.getName() == null ? "" : cls.getName(); + } + if (psi instanceof PsiClassType classType) { + return classType.getClassName(); + } + return fullyQualifiedName(); + }); } @Override public Symbol.TypeSymbol symbol() { - return sema.typeSymbol(typeBinding); + return sema.read(() -> sema.typeSymbol(this)); } @Override public Type erasure() { - return sema.type(typeBinding.getErasure()); + return sema.read(() -> sema.type(TypeConversionUtil.erasure(psi))); } @Override public Type elementType() { - return sema.type(typeBinding.getComponentType()); + return sema.read(() -> psi instanceof PsiArrayType array ? sema.type(array.getComponentType()) : Type.UNKNOWN); } @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj instanceof JType other) { - return areEqual(this.typeBinding, other.typeBinding); - } - return false; + public boolean isParameterized() { + return sema.read(() -> psi instanceof PsiClassType cls && !cls.isRaw() && !typeArguments().isEmpty() + && !typeArguments().equals(declaringType().typeArguments())); } @Override - public int hashCode() { - return fullyQualifiedName().hashCode(); + public List typeArguments() { + return sema.read(() -> { + if (!(psi instanceof PsiClassType cls) || cls.isRaw()) { + return List.of(); + } + var resolved = cls.resolveGenerics(); + if (resolved.getElement() == null) { + return List.of(); + } + var arguments = Arrays.stream(resolved.getElement().getTypeParameters()).map(p -> resolved.getSubstitutor().substitute(p)).toArray(com.intellij.psi.PsiType[]::new); + if (IntStream.range(0, arguments.length).allMatch(i -> arguments[i] instanceof PsiClassType argument + && argument.resolve() == resolved.getElement().getTypeParameters()[i])) { + return List.of(); + } + return sema.types(arguments); + }); } - static boolean areEqual(@Nullable ITypeBinding binding1, @Nullable ITypeBinding binding2) { - if (binding1 == null || binding2 == null) { - return binding1 == binding2; - } - if (binding1.isWildcardType()) { - return binding2.isWildcardType() - && binding1.isUpperbound() == binding2.isUpperbound() - && areEqual(binding1.getBound(), binding2.getBound()); - } - // TODO compare declaring class, method, member - return binding1.getTypeDeclaration().equals(binding2.getTypeDeclaration()) - && isParameterizedOrGeneric(binding1) == isParameterizedOrGeneric(binding2) - && binding1.isRawType() == binding2.isRawType() - && Arrays.equals(binding1.getTypeParameters(), binding2.getTypeParameters()) - && Arrays.equals(binding1.getTypeArguments(), binding2.getTypeArguments()); - } - - static ITypeBinding normalize(ITypeBinding typeBinding) { - ITypeBinding typeDeclaration = typeBinding.getTypeDeclaration(); - if (typeBinding.isLocal()) { - return typeDeclaration; - } - return typeBinding.isParameterizedType() && Arrays.equals(typeDeclaration.getTypeParameters(), typeBinding.getTypeArguments()) - ? typeDeclaration - : typeBinding; + @Override + public Type[] getIntersectionTypes() { + return sema.read(() -> psi instanceof PsiIntersectionType intersection + ? sema.types(intersection.getConjuncts()).toArray(Type[]::new) : new Type[] {this}); } - private static boolean isParameterizedOrGeneric(ITypeBinding typeBinding) { - return typeBinding.isParameterizedType() || typeBinding.isGenericType(); + @Override + public boolean equals(Object other) { + return other instanceof JType type && key.equals(type.key); } @Override - public boolean isParameterized() { - return typeBinding.isParameterizedType() - // when diamond operator is not fully resolved by ECJ, there is 0 typeArguments, while ECJ - // knows it is a Parameterized Type - && !typeArguments().isEmpty(); + public int hashCode() { + return fullyQualifiedName().hashCode(); } @Override - public List typeArguments() { - if (typeArguments == null) { - typeArguments = sema.types(typeBinding.getTypeArguments()); - } - return typeArguments; + public String toString() { + return name(); } - } diff --git a/java-frontend/src/main/java/org/sonar/java/model/JTypeSymbol.java b/java-frontend/src/main/java/org/sonar/java/model/JTypeSymbol.java index faf20e1af32..ebf43b85f9e 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/JTypeSymbol.java +++ b/java-frontend/src/main/java/org/sonar/java/model/JTypeSymbol.java @@ -16,19 +16,20 @@ */ package org.sonar.java.model; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiClassType; +import com.intellij.psi.PsiSubstitutor; +import com.intellij.psi.PsiTypeParameter; +import com.intellij.psi.impl.light.LightDefaultConstructor; +import com.intellij.psi.util.PsiTreeUtil; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collection; -import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; -import java.util.stream.Stream; -import javax.annotation.CheckForNull; -import javax.annotation.Nullable; -import org.eclipse.jdt.core.dom.ITypeBinding; import org.sonar.plugins.java.api.semantic.Symbol; import org.sonar.plugins.java.api.semantic.Type; import org.sonar.plugins.java.api.tree.ClassTree; @@ -36,222 +37,216 @@ import org.sonar.plugins.java.api.tree.VariableTree; final class JTypeSymbol extends JSymbol implements Symbol.TypeSymbol { + private final JType type; + final SpecialField thisSymbol = new SpecialField(false); + final SpecialField superSymbol = new SpecialField(true); - /** - * Cache for {@link #superClass()}. - */ - private Type superclass = Type.UNKNOWN; - - /** - * Cache for {@link #interfaces()}. - */ - private List interfaces; + JTypeSymbol(JSema sema, JType type, String key) { + super(sema, type.resolvedClass(), key); + this.type = type; + } - /** - * Cache for {@link #memberSymbols()}. - */ - private Collection memberSymbols; + @Override + public Type type() { + return type; + } - /** - * Cache for {@link #superTypes()}. - */ - private Set superTypes; + @Override + public String name() { + return type.name(); + } - final SpecialField superSymbol = new SpecialField() { - @Override - public String name() { - return "super"; - } + @Override + public boolean isUnknown() { + return type.isUnknown(); + } - @Override - public Type type() { - if (typeBinding().isInterface()) { - // JLS § 15.12.1: - // for "T.super.foo()", if T is an interface, 'super' keyword is used to access method of the interface itself - return JTypeSymbol.this.type(); + @Override + public Symbol owner() { + return sema.read(() -> { + if (isUnknown()) { + return Symbol.UNKNOWN_SYMBOL; } - Type superClass = JTypeSymbol.this.superClass(); - return superClass == null ? Type.UNKNOWN : superClass; - } - }; - - final SpecialField thisSymbol = new SpecialField() { - @Override - public String name() { - return "this"; - } - - @Override - public Type type() { - return JTypeSymbol.this.type(); - } - }; + if (element instanceof PsiClass cls && cls.getContainingClass() != null && !isStatic()) { + var substitution = ((PsiClassType) type.psi).resolveGenerics().getSubstitutor(); + return sema.type(JavaPsiFacade.getElementFactory(sema.project).createType(cls.getContainingClass(), substitution)).symbol(); + } + return element == null ? Symbol.ROOT_PACKAGE : super.owner(); + }); + } - JTypeSymbol(JSema sema, ITypeBinding typeBinding) { - super(sema, typeBinding); + @Override + public TypeSymbol enclosingClass() { + return sema.read(() -> { + var enclosing = element == null ? null : PsiTreeUtil.getParentOfType(element, PsiClass.class); + return enclosing == null ? this : (TypeSymbol) sema.symbol(enclosing); + }); } - ITypeBinding typeBinding() { - return (ITypeBinding) binding; + @Override + public ClassTree declaration() { + return (ClassTree) super.declaration(); } - @CheckForNull @Override - public Type superClass() { - if (superclass == Type.UNKNOWN) { - superclass = convertSuperClass(); - } - return superclass; + public boolean isAnnotation() { + return sema.read(() -> element instanceof PsiClass cls && cls.isAnnotationType()); } - @CheckForNull - private Type convertSuperClass() { - if (typeBinding().isInterface() || typeBinding().isArray()) { - ITypeBinding objectBinding = sema.resolveType("java.lang.Object"); - return objectBinding != null ? sema.type(objectBinding) : Type.UNKNOWN; - } else if (typeBinding().getSuperclass() == null) { - // java.lang.Object - return null; - } else { - return sema.type(typeBinding().getSuperclass()); - } + @Override + public Type superClass() { + return sema.read(() -> { + if (type.isArray() || isInterface()) { + return sema.getClassType("java.lang.Object"); + } + if (!(element instanceof PsiClass cls)) { + return null; + } + if (cls instanceof PsiTypeParameter) { + var supers = type.directSuperTypes(); + return supers.stream().filter(t -> !t.symbol().isInterface()).findFirst().orElse(sema.getClassType("java.lang.Object")); + } + var parents = cls.getExtendsListTypes(); + if (parents.length != 0) { + var substitution = ((PsiClassType) type.psi).resolveGenerics().getSubstitutor(); + return sema.type(substitution.substitute(parents[0])); + } + var parent = cls.getSuperClass(); + return parent == null ? null : sema.type(cls.getSuperTypes()[0]); + }); } @Override public List interfaces() { - if (interfaces == null) { - interfaces = sema.types(typeBinding().getInterfaces()); - } - return interfaces; + return sema.read(() -> { + if (element instanceof PsiClass cls && !(cls instanceof PsiTypeParameter)) { + var parents = cls.isInterface() ? cls.getExtendsListTypes() : cls.getImplementsListTypes(); + var substitution = ((PsiClassType) type.psi).resolveGenerics().getSubstitutor(); + return java.util.Arrays.stream(parents).map(parent -> sema.type(substitution.substitute(parent))).toList(); + } + return type.directSuperTypes().stream().filter(t -> t.isUnknown() || t.symbol().isInterface()).toList(); + }); } @Override public Collection memberSymbols() { - if (memberSymbols == null) { - memberSymbols = convertMemberSymbols(); - } - return memberSymbols; - } - - private Collection convertMemberSymbols() { - return Stream.concat( - Stream.concat( - Arrays.stream(typeBinding().getDeclaredTypes()).map(sema::typeSymbol), - Arrays.stream(typeBinding().getDeclaredFields()).map(sema::variableSymbol)), - Arrays.stream(typeBinding().getDeclaredMethods()).map(sema::methodSymbol)) - .collect(Collectors.toCollection(ArrayList::new)); + return sema.read(() -> { + List result = new ArrayList<>(); + if (element instanceof PsiClass cls) { + for (var child : cls.getInnerClasses()) { + result.add(sema.symbol(child)); + } + var substitution = type.psi instanceof PsiClassType classType ? classType.resolveGenerics().getSubstitutor() : PsiSubstitutor.EMPTY; + for (var field : cls.getFields()) { + result.add(sema.variable(field, substitution)); + } + for (var method : cls.getMethods()) { + result.add(sema.method(method, substitution)); + } + var constructor = LightDefaultConstructor.create(cls); + if (constructor != null) { + result.add(sema.method(constructor, substitution)); + } + } + return result; + }); } @Override public Collection lookupSymbols(String name) { - return memberSymbols().stream() - .filter(m -> name.equals(m.name())) - .collect(Collectors.toSet()); - } - - @Nullable - @Override - public ClassTree declaration() { - return (ClassTree) super.declaration(); + return memberSymbols().stream().filter(symbol -> symbol.name().equals(name)).collect(Collectors.toSet()); } @Override public Set superTypes() { - if (superTypes == null) { - if (isUnknown()) { - superTypes = Collections.emptySet(); - } else { - superTypes = new HashSet<>(); - collectSuperTypes(superTypes, sema, typeBinding()); - } - } - return superTypes; + return sema.read(() -> { + Set result = new HashSet<>(); + collect(type, result); + return result; + }); } - private static void collectSuperTypes(Set result, JSema sema, ITypeBinding typeBinding) { - ITypeBinding s = typeBinding.getSuperclass(); - if (s != null) { - result.add(sema.type(s)); - collectSuperTypes(result, sema, s); + private static void collect(Type type, Set result) { + for (var parent : type.directSuperTypes()) { + if (result.add(parent)) { + collect(parent, result); + } } - Arrays.stream(typeBinding.getInterfaces()).forEach(i -> { - result.add(sema.type(i)); - collectSuperTypes(result, sema, i); - }); } @Override - @Nullable public TypeSymbol outermostClass() { - Symbol symbol = this; - Symbol result = null; - while (symbol != null && !symbol.isPackageSymbol()) { - result = symbol; - symbol = symbol.owner(); + Symbol current = this; + TypeSymbol result = this; + while (current != null && !current.isPackageSymbol() && !current.isUnknown()) { + if (current instanceof TypeSymbol cls) { + result = cls; + } + current = current.owner(); } - return (Symbol.TypeSymbol) result; + return result; } - @Override - public boolean isAnnotation() { - return !isUnknown() && typeBinding().isAnnotation(); - } + final class SpecialField extends Symbols.DefaultSymbol implements VariableSymbol { + private final boolean isSuper; + + SpecialField(boolean isSuper) { + this.isSuper = isSuper; + } - abstract class SpecialField extends Symbols.DefaultSymbol implements Symbol.VariableSymbol { @Override - public final Symbol owner() { + public String name() { + return isSuper ? "super" : "this"; + } + + @Override + public Symbol owner() { return JTypeSymbol.this; } @Override - public final boolean isVariableSymbol() { + public Type type() { + return isSuper && !JTypeSymbol.this.isInterface() ? Optional.ofNullable(superClass()).orElse(Type.UNKNOWN) : type; + } + + @Override + public boolean isVariableSymbol() { return true; } @Override - public final boolean isFinal() { + public boolean isFinal() { return true; } @Override - public final boolean isUnknown() { + public boolean isUnknown() { return false; } @Override - public final TypeSymbol enclosingClass() { + public TypeSymbol enclosingClass() { return JTypeSymbol.this; } @Override - public final List usages() { - return Collections.emptyList(); + public List usages() { + return List.of(); } - @Nullable @Override - public final VariableTree declaration() { + public VariableTree declaration() { return null; } @Override - public final boolean isEffectivelyFinal(){ - return false; - } - @Override - public final Optional constantValue() { - return Optional.empty(); - } - - @Override - public final boolean isLocalVariable() { + public boolean isEffectivelyFinal() { return false; } @Override - public final boolean isParameter() { - return false; + public Optional constantValue() { + return Optional.empty(); } } - } diff --git a/java-frontend/src/main/java/org/sonar/java/model/JVariableSymbol.java b/java-frontend/src/main/java/org/sonar/java/model/JVariableSymbol.java index dd73f136563..2fd3b8b2138 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/JVariableSymbol.java +++ b/java-frontend/src/main/java/org/sonar/java/model/JVariableSymbol.java @@ -16,156 +16,134 @@ */ package org.sonar.java.model; -import java.util.Collections; -import java.util.List; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.JavaTokenType; +import com.intellij.psi.PsiAssignmentExpression; +import com.intellij.psi.PsiClassInitializer; +import com.intellij.psi.PsiField; +import com.intellij.psi.PsiLambdaExpression; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiParameter; +import com.intellij.psi.PsiPostfixExpression; +import com.intellij.psi.PsiPrefixExpression; +import com.intellij.psi.PsiReferenceExpression; +import com.intellij.psi.PsiResourceVariable; +import com.intellij.psi.PsiSubstitutor; +import com.intellij.psi.PsiVariable; +import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.psi.util.PsiUtil; import java.util.Optional; -import javax.annotation.Nullable; -import org.eclipse.jdt.core.dom.IMethodBinding; -import org.eclipse.jdt.core.dom.ITypeBinding; -import org.eclipse.jdt.core.dom.IVariableBinding; import org.sonar.plugins.java.api.semantic.Symbol; -import org.sonar.plugins.java.api.semantic.SymbolMetadata; import org.sonar.plugins.java.api.semantic.Type; -import org.sonar.plugins.java.api.tree.IdentifierTree; import org.sonar.plugins.java.api.tree.VariableTree; final class JVariableSymbol extends JSymbol implements Symbol.VariableSymbol { + private final PsiVariable variable; + final PsiSubstitutor substitutor; - // cache for this.constantValue() - private boolean constantValueComputed = false; - private Optional constantValue; + JVariableSymbol(JSema sema, PsiVariable variable, PsiSubstitutor substitutor, String key) { + super(sema, variable, key); + this.variable = variable; + this.substitutor = substitutor; + } - JVariableSymbol(JSema sema, IVariableBinding variableBinding) { - super(sema, variableBinding); + @Override + public Type type() { + return sema.read(() -> { + var type = sema.type(substitutor.substitute(variable.getType())); + var original = variable.getContainingFile().getOriginalFile(); + boolean resource = variable instanceof PsiResourceVariable || original != variable.getContainingFile() + && PsiTreeUtil.getParentOfType(original.findElementAt(variable.getTextRange().getStartOffset()), PsiResourceVariable.class) != null; + return resource && !type.isUnknown() && !type.isSubtypeOf("java.lang.AutoCloseable") ? Type.UNKNOWN : type; + }); } - @Nullable @Override - public VariableTree declaration() { - return (VariableTree) super.declaration(); + public Symbol owner() { + return sema.read(() -> { + if (variable instanceof PsiField field) { + var cls = field.getContainingClass(); + return PsiUtil.isArrayClass(cls) ? Symbol.UNKNOWN_SYMBOL + : sema.type(JavaPsiFacade.getElementFactory(sema.project).createType(cls, substitutor)).symbol(); + } + return super.owner(); + }); } @Override - public boolean isEffectivelyFinal() { - return ((IVariableBinding)binding).isEffectivelyFinal(); + public VariableTree declaration() { + return (VariableTree) super.declaration(); } @Override - public Optional constantValue() { - if (!constantValueComputed) { - constantValueComputed = true; - if (!isFinal() || !isStatic()) { - constantValue = Optional.empty(); - } else { - Object c = ((IVariableBinding) binding).getConstantValue(); - if (c instanceof Short shortValue) { - c = Integer.valueOf(shortValue); - } else if (c instanceof Byte byteValue) { - c = Integer.valueOf(byteValue); - } else if (c instanceof Character characterValue) { - c = Integer.valueOf(characterValue); - } - constantValue = Optional.ofNullable(c); - } - } - return constantValue; + public TypeSymbol enclosingClass() { + return variable instanceof PsiField ? owner() instanceof TypeSymbol cls ? cls : TypeSymbol.UNKNOWN_TYPE : super.enclosingClass(); } @Override public boolean isLocalVariable() { - Symbol owner = owner(); - return owner != null && owner.isMethodSymbol(); + return !isPlaceholder() && owner() instanceof Symbol.MethodSymbol; } @Override public boolean isParameter() { - return ((IVariableBinding) binding).isParameter(); + return variable instanceof PsiParameter; } + private boolean isPlaceholder() { + return sema.read(() -> variable instanceof PsiParameter parameter && parameter.getDeclarationScope() instanceof PsiMethod + && !sema.declarations.containsKey(sema.key(variable))); + } - static class ParameterPlaceholderSymbol extends Symbols.DefaultSymbol implements Symbol.VariableSymbol { - private final String name; - private final Symbol owner; - private final Type type; - private final SymbolMetadata metadata; - - ParameterPlaceholderSymbol(int index, JSema sema, IMethodBinding owner, ITypeBinding typeBinding) { - this.name = "arg" + index; - this.owner = sema.methodSymbol(owner); - this.type = sema.type(typeBinding); - this.metadata = EcjSymbolMetadata.of(sema, this, typeBinding, owner.getParameterAnnotations(index)); - } - - @Override - public String name() { - return name; - } - - @Override - public Symbol owner() { - return owner; - } - - @Override - public Type type() { - return type; - } - - @Override - public boolean isUnknown() { - return false; - } - - @Override - public TypeSymbol enclosingClass() { - return owner.enclosingClass(); - } - - @Override - public List usages() { - return Collections.emptyList(); - } - - @Override - public VariableTree declaration() { - return null; - } - - @Override - public boolean isEffectivelyFinal() { - return false; - } - - @Override - public Optional constantValue() { - return Optional.empty(); - } - - @Override - public boolean isLocalVariable() { - return false; - } - - @Override - public boolean isParameter() { - return true; - } - - @Override - public SymbolMetadata metadata() { - return metadata; - } + @Override + public String name() { + return isPlaceholder() ? sema.read(() -> "arg" + ((PsiMethod) ((PsiParameter) variable).getDeclarationScope()).getParameterList().getParameterIndex((PsiParameter) variable)) : super.name(); + } - @Override - public boolean isVariableSymbol() { - return true; - } + @Override + public boolean isFinal() { + return !isPlaceholder() && super.isFinal(); + } - @Override - public boolean isFinal() { - // From a caller perspective, it is not useful (and even not possible) to know if the parameter is final. - return false; - } + @Override + public boolean isEffectivelyFinal() { + return sema.read(() -> { + if (isPlaceholder() || isFinal() || variable instanceof PsiField) { + return false; + } + var scope = PsiTreeUtil.getParentOfType(variable, PsiMethod.class, PsiLambdaExpression.class, PsiClassInitializer.class); + if (scope == null) { + return false; + } + int assignments = 0; + for (var reference : PsiTreeUtil.findChildrenOfType(scope, PsiReferenceExpression.class)) { + if (reference.resolve() == variable) { + var parent = reference.getParent(); + if (parent instanceof PsiAssignmentExpression assignment && assignment.getLExpression() == reference) { + assignments++; + } else if (parent instanceof PsiPostfixExpression || parent instanceof PsiPrefixExpression prefix + && (prefix.getOperationTokenType() == JavaTokenType.PLUSPLUS || prefix.getOperationTokenType() == JavaTokenType.MINUSMINUS)) { + return false; + } + } + } + return assignments == 0 || variable.getInitializer() == null && !(variable instanceof PsiParameter) && assignments == 1; + }); + } + @Override + public Optional constantValue() { + return sema.read(() -> { + if (!isStatic() || !isFinal()) { + return Optional.empty(); + } + Object value = variable.computeConstantValue(); + if (value instanceof Byte || value instanceof Short) { + value = ((Number) value).intValue(); + } else if (value instanceof Character character) { + value = (int) character; + } + return Optional.ofNullable(value); + }); } } diff --git a/java-frontend/src/main/java/org/sonar/java/model/LineColumnConverter.java b/java-frontend/src/main/java/org/sonar/java/model/LineColumnConverter.java index 8e207a750de..37bb6e37355 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/LineColumnConverter.java +++ b/java-frontend/src/main/java/org/sonar/java/model/LineColumnConverter.java @@ -21,14 +21,7 @@ import java.util.regex.Pattern; import org.sonar.plugins.java.api.location.Position; -/** - * There is a different convention in the JDT for line and column numbers. - * The difference is only when there are some line continuation characters in text blocks. - * Eclipse does not count the line continuation as a new line. - * So we cannot use the following methods to get the line and column number: - * {@link org.eclipse.jdt.core.dom.CompilationUnit#getColumnNumber(int position)} - * {@link org.eclipse.jdt.core.dom.CompilationUnit#getLineNumber(int position)} - */ +/** Maps physical UTF-16 offsets to source lines, including continuation lines inside text blocks. */ public class LineColumnConverter { private static final Pattern LINE_SEPARATOR_PATTERN = Pattern.compile("\r\n?|\n"); diff --git a/java-frontend/src/main/java/org/sonar/java/model/PsiFrontendBackend.java b/java-frontend/src/main/java/org/sonar/java/model/PsiFrontendBackend.java new file mode 100644 index 00000000000..fc15cdc1c73 --- /dev/null +++ b/java-frontend/src/main/java/org/sonar/java/model/PsiFrontendBackend.java @@ -0,0 +1,119 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import com.intellij.openapi.progress.ProcessCanceledException; +import java.io.File; +import java.io.IOException; +import java.io.UncheckedIOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.function.BiConsumer; +import java.util.function.BooleanSupplier; +import java.util.function.Supplier; +import org.eclipse.core.runtime.OperationCanceledException; +import org.sonar.api.batch.fs.InputFile; +import org.sonar.java.ProgressMonitor; +import org.sonar.java.psi.JavaPsiConfiguration; +import org.sonar.java.psi.JavaPsiEnvironment; + +final class PsiFrontendBackend implements FrontendBackend { + @Override + public FrontendSession open(FrontendConfiguration configuration) { + return new Session(configuration); + } + + static T cancellable(Supplier action) { + try { + if (Thread.currentThread().isInterrupted()) { + throw new OperationCanceledException("Java analysis interrupted"); + } + return action.get(); + } catch (ProcessCanceledException failure) { + var canceled = new OperationCanceledException(failure.getMessage()); + canceled.initCause(failure); + throw canceled; + } + } + + private static final class Session extends FrontendSession { + private final JavaPsiConfiguration configuration; + + private Session(FrontendConfiguration configuration) { + this.configuration = new JavaPsiConfiguration(null, configuration.classpath().stream().map(File::toPath).toList(), + Integer.parseInt(configuration.sourceVersion()), configuration.previewEnabled(), configuration.ignoreUnnamedModuleForSplitPackage()); + } + + @Override + JavaTree.CompilationUnitTreeImpl parse(String unitName, String source) { + return cancellable(() -> { + var snapshot = new JavaPsiEnvironment.SourceSnapshot(Path.of(unitName), PsiTokenIndex.unicodeInput(source).text(), StandardCharsets.UTF_8); + var environment = JavaPsiEnvironment.open(configuration, List.of(snapshot), () -> false); + var cleaner = own(environment::close); + return environment.read((project, files) -> JParser.convert(environment, project, files.getFirst(), configuration, source, cleaner)); + }); + } + + /** Keeps all decoded inputs visible in one owned project while delivering callbacks in input order. */ + @Override + void parseBatch(FrontendBatch inputs, ProgressMonitor monitor, BiConsumer action) { + monitor.beginTask("Parse Java sources", inputs.inputs().size()); + cancellable(() -> { + BooleanSupplier canceled = () -> monitor.isCanceled() || Thread.currentThread().isInterrupted(); + checkCanceled(canceled); + var snapshots = new ArrayList(); + var sources = new ArrayList(); + for (var input : inputs.inputs()) { + checkCanceled(canceled); + try { + var source = input.contents(); + sources.add(source); + snapshots.add(new JavaPsiEnvironment.SourceSnapshot(Path.of(input.absolutePath()), PsiTokenIndex.unicodeInput(source).text(), input.charset())); + } catch (IOException failure) { + throw new UncheckedIOException(failure); + } + } + if (snapshots.isEmpty()) { + return null; + } + var environment = JavaPsiEnvironment.open(configuration, snapshots, canceled); + var cleaner = own(environment::close); + environment.read((project, files) -> { + for (int i = 0; i < inputs.inputs().size(); i++) { + checkCanceled(canceled); + var input = inputs.inputs().get(i); + var file = files.get(i); + var source = sources.get(i); + action.accept(input, () -> cancellable(() -> JParser.convert(environment, project, file, configuration, source, cleaner))); + monitor.worked(1); + } + checkCanceled(canceled); + return null; + }); + return null; + }); + } + + private static void checkCanceled(BooleanSupplier canceled) { + if (canceled.getAsBoolean()) { + throw new OperationCanceledException("Java analysis cancelled"); + } + } + } +} diff --git a/java-frontend/src/main/java/org/sonar/java/model/PsiSemanticAttachment.java b/java-frontend/src/main/java/org/sonar/java/model/PsiSemanticAttachment.java new file mode 100644 index 00000000000..3c332ad8591 --- /dev/null +++ b/java-frontend/src/main/java/org/sonar/java/model/PsiSemanticAttachment.java @@ -0,0 +1,359 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiAnnotation; +import com.intellij.psi.PsiArrayType; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiDeconstructionPattern; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiEnumConstant; +import com.intellij.psi.PsiExpression; +import com.intellij.psi.PsiField; +import com.intellij.psi.PsiFunctionalExpression; +import com.intellij.psi.PsiIdentifier; +import com.intellij.psi.PsiImportModuleStatement; +import com.intellij.psi.PsiImportStatementBase; +import com.intellij.psi.PsiJavaCodeReferenceElement; +import com.intellij.psi.PsiLambdaExpression; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiMethodCallExpression; +import com.intellij.psi.PsiMethodReferenceExpression; +import com.intellij.psi.PsiNameIdentifierOwner; +import com.intellij.psi.PsiNewExpression; +import com.intellij.psi.PsiPackage; +import com.intellij.psi.PsiQualifiedExpression; +import com.intellij.psi.PsiReferenceExpression; +import com.intellij.psi.PsiReturnStatement; +import com.intellij.psi.PsiSubstitutor; +import com.intellij.psi.PsiSuperExpression; +import com.intellij.psi.PsiSwitchExpression; +import com.intellij.psi.PsiThisExpression; +import com.intellij.psi.PsiTypeElement; +import com.intellij.psi.PsiTypeParameter; +import com.intellij.psi.PsiTypeTestPattern; +import com.intellij.psi.PsiVariable; +import com.intellij.psi.PsiYieldStatement; +import com.intellij.psi.util.PsiTreeUtil; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.IdentityHashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.function.Supplier; +import org.sonar.java.model.declaration.ClassTreeImpl; +import org.sonar.java.model.declaration.EnumConstantTreeImpl; +import org.sonar.java.model.declaration.MethodTreeImpl; +import org.sonar.java.model.declaration.VariableTreeImpl; +import org.sonar.java.model.expression.IdentifierTreeImpl; +import org.sonar.java.model.expression.LambdaExpressionTreeImpl; +import org.sonar.java.model.expression.MemberSelectExpressionTreeImpl; +import org.sonar.java.model.expression.MethodInvocationTreeImpl; +import org.sonar.java.model.expression.MethodReferenceTreeImpl; +import org.sonar.java.model.expression.NewClassTreeImpl; +import org.sonar.java.model.pattern.AbstractPatternTree; +import org.sonar.plugins.java.api.semantic.Symbol; +import org.sonar.plugins.java.api.semantic.Type; +import org.sonar.plugins.java.api.tree.ArrayTypeTree; +import org.sonar.plugins.java.api.tree.IdentifierTree; +import org.sonar.plugins.java.api.tree.Tree; + +final class PsiSemanticAttachment implements Supplier { + private final JSema sema; + private final Supplier factory; + private T value; + + PsiSemanticAttachment(JSema sema, Supplier factory) { + this.sema = sema; + this.factory = factory; + } + + @Override + public T get() { + return sema.read(() -> { + if (value == null) { + value = Objects.requireNonNull(factory.get()); + } + return value; + }); + } + + static void attach(JSema sema, JavaTree.CompilationUnitTreeImpl root, Map> nodes) { + root.sema = sema; + Map origins = new IdentityHashMap<>(); + nodes.forEach((element, trees) -> trees.forEach(tree -> { + if (!(element instanceof PsiIdentifier)) { + origins.put(tree, element); + } else { + origins.putIfAbsent(tree, element); + } + })); + origins.forEach((tree, element) -> { + if (tree instanceof IdentifierTreeImpl identifier && identifier.labelSymbol == null) { + identifier.symbolSupplier = new PsiSemanticAttachment<>(sema, () -> insideImport(element) ? Symbol.UNKNOWN_SYMBOL : symbol(sema, element)); + } + }); + origins.forEach((tree, element) -> attachNode(sema, tree, element)); + origins.forEach((tree, element) -> { + if (tree instanceof VariableTreeImpl variable && element instanceof PsiVariable declaration) { + attachType(sema, variable.type(), declaration.getType()); + } + }); + origins.forEach((tree, element) -> { + if (tree instanceof ArrayTypeTree && !(tree.parent() instanceof ArrayTypeTree) && element instanceof PsiTypeElement type) { + attachType(sema, tree, type.getType()); + } + }); + origins.forEach((tree, element) -> { + if (tree instanceof MethodInvocationTreeImpl || tree instanceof NewClassTreeImpl || tree instanceof MethodReferenceTreeImpl + || tree instanceof EnumConstantTreeImpl) { + attachNode(sema, tree, element); + } + }); + origins.forEach((tree, element) -> { + if (tree instanceof IdentifierTreeImpl identifier && identifier.labelSymbol == null) { + var resolved = identifier.symbol(); + var target = resolved instanceof JSymbol symbol ? symbol.element : null; + if (target != null && (!isDeclarationName(element) || element.getParent() instanceof PsiEnumConstant && resolved.isMethodSymbol()) && !insideImport(element)) { + var usages = sema.usages.computeIfAbsent(sema.key(target), unused -> new ArrayList<>()); + if (!usages.contains(identifier)) { + usages.add(identifier); + } + } + } + }); + sema.usages.values().forEach(usages -> usages.sort(Comparator + .comparingInt((IdentifierTree identifier) -> identifier.identifierToken().range().start().line()) + .thenComparingInt(identifier -> identifier.identifierToken().range().start().columnOffset()))); + } + + private static void attachUnnamedPattern(JSema sema, com.intellij.psi.PsiUnnamedPattern unnamed, VariableTreeImpl variable) { + var declaration = new com.intellij.psi.impl.light.LightVariableBuilder<>("_", unnamed.getTypeElement().getType(), unnamed) { + @Override + public PsiElement getParent() { + return unnamed; + } + + @Override + public com.intellij.psi.PsiFile getContainingFile() { + return unnamed.getContainingFile(); + } + + @Override + public com.intellij.openapi.util.TextRange getTextRange() { + return unnamed.getTextRange(); + } + }; + variable.variableSymbol = new PsiSemanticAttachment<>(sema, () -> sema.symbol(declaration)); + sema.declarations.put(sema.key(declaration), variable); + attachType(sema, variable.type(), declaration.getType()); + } + + private static void attachNode(JSema sema, Tree tree, PsiElement element) { + if (tree instanceof AbstractTypedTree typed) { + typed.type = insideImport(element) ? SemanticValues.UNKNOWN_TYPE : new PsiSemanticAttachment<>(sema, () -> type(sema, element)); + if (tree instanceof IdentifierTreeImpl identifier && identifier.name().equals("class")) { + typed.type = SemanticValues.UNKNOWN_TYPE; + } + } + if (tree instanceof AbstractPatternTree pattern) { + pattern.type = new PsiSemanticAttachment<>(sema, () -> type(sema, element)); + if (element instanceof com.intellij.psi.PsiUnnamedPattern unnamed && tree instanceof org.sonar.plugins.java.api.tree.TypePatternTree typePattern) { + attachUnnamedPattern(sema, unnamed, (VariableTreeImpl) typePattern.patternVariable()); + } + } + if (tree instanceof ClassTreeImpl cls && element instanceof PsiClass declaration) { + cls.typeSymbol = new PsiSemanticAttachment<>(sema, () -> (Symbol.TypeSymbol) sema.symbol(declaration)); + sema.declarations.put(sema.key(declaration), tree); + } else if (tree instanceof MethodTreeImpl method && element instanceof PsiMethod declaration) { + method.methodSymbol = new PsiSemanticAttachment<>(sema, () -> brokenMethod(declaration) ? Symbol.MethodSymbol.UNKNOWN_METHOD : sema.method(declaration, PsiSubstitutor.EMPTY)); + if (!brokenMethod(declaration)) { + sema.declarations.put(sema.key(declaration), tree); + } + } else if (tree instanceof VariableTreeImpl variable && element instanceof PsiVariable declaration) { + variable.variableSymbol = new PsiSemanticAttachment<>(sema, () -> sema.symbol(declaration)); + sema.declarations.put(sema.key(declaration), tree); + sema.symbol(declaration); + if (declaration instanceof PsiEnumConstant constant && variable instanceof EnumConstantTreeImpl enumeration) { + var creation = (NewClassTreeImpl) enumeration.initializer(); + ((IdentifierTreeImpl) creation.getConstructorIdentifier()).symbolSupplier = new PsiSemanticAttachment<>(sema, () -> sema.method(constant.resolveMethodGenerics())); + } + } else if (tree instanceof LambdaExpressionTreeImpl lambda && element instanceof PsiLambdaExpression declaration) { + lambda.methodSymbol = new PsiSemanticAttachment<>(sema, () -> sema.lambda(declaration)); + } else if (tree instanceof MethodInvocationTreeImpl invocation && element instanceof PsiMethodCallExpression call) { + invocation.methodSymbolSupplier = new PsiSemanticAttachment<>(sema, () -> sema.method(call)); + var identifier = invocation.methodSelect() instanceof MemberSelectExpressionTreeImpl select ? select.identifier() : invocation.methodSelect(); + ((IdentifierTreeImpl) identifier).symbolSupplier = invocation.methodSymbolSupplier::get; + if (invocation.methodSelect() instanceof AbstractTypedTree selected) { + selected.type = SemanticValues.UNKNOWN_TYPE; + } + if (call.getMethodExpression().getReferenceNameElement() != null + && (call.getMethodExpression().textMatches("this") || call.getMethodExpression().textMatches("super") || call.getMethodExpression().getReferenceName().equals("super"))) { + ((AbstractTypedTree) invocation).type = new PsiSemanticAttachment<>(sema, () -> { + var owner = sema.symbol(PsiTreeUtil.getParentOfType(call, PsiClass.class)).type(); + return call.getMethodExpression().getReferenceName().equals("this") ? owner : owner.symbol().superClass(); + }); + } + } else if (tree instanceof NewClassTreeImpl creation && element instanceof PsiNewExpression expression) { + ((IdentifierTreeImpl) creation.getConstructorIdentifier()).symbolSupplier = new PsiSemanticAttachment<>(sema, () -> sema.constructor(expression)); + } else if (tree instanceof MethodReferenceTreeImpl reference && element instanceof PsiMethodReferenceExpression expression) { + ((IdentifierTreeImpl) reference.method()).symbolSupplier = new PsiSemanticAttachment<>(sema, () -> sema.method(expression.advancedResolve(false))); + } else if (tree instanceof JavaTree.ImportTreeImpl imported && element instanceof PsiImportStatementBase statement) { + imported.symbolSupplier = statement instanceof PsiImportModuleStatement ? () -> null + : new PsiSemanticAttachment<>(sema, () -> sema.symbol(statement.resolve())); + } else if (tree instanceof TypeParameterTreeImpl parameter && element instanceof PsiTypeParameter declaration) { + parameter.typeSymbol = new PsiSemanticAttachment<>(sema, () -> sema.symbol(declaration)); + } + if (element instanceof PsiThisExpression || element instanceof PsiSuperExpression) { + var identifier = tree instanceof MemberSelectExpressionTreeImpl select ? select.identifier() : tree; + if (identifier instanceof IdentifierTreeImpl id) { + id.symbolSupplier = new PsiSemanticAttachment<>(sema, () -> symbol(sema, element)); + } + } + } + + private static void attachType(JSema sema, Tree tree, com.intellij.psi.PsiType type) { + if (tree instanceof AbstractTypedTree typed) { + typed.type = new PsiSemanticAttachment<>(sema, () -> sema.type(type)); + } + if (tree instanceof ArrayTypeTree array && type instanceof PsiArrayType arrayType) { + attachType(sema, array.type(), arrayType.getComponentType()); + } + } + + private static boolean insideImport(PsiElement element) { + return PsiTreeUtil.getParentOfType(element, PsiImportStatementBase.class) != null; + } + + private static boolean brokenMethod(PsiMethod method) { + var owner = method.getContainingClass(); + if (owner != null) { + for (var previous : owner.getMethods()) { + if (previous == method) { + break; + } + if (previous.getName().equals(method.getName()) && Arrays.equals( + Arrays.stream(previous.getParameterList().getParameters()).map(parameter -> com.intellij.psi.util.TypeConversionUtil.erasure(parameter.getType()).getCanonicalText()).toArray(), + Arrays.stream(method.getParameterList().getParameters()).map(parameter -> com.intellij.psi.util.TypeConversionUtil.erasure(parameter.getType()).getCanonicalText()).toArray())) { + return true; + } + } + } + return method.getReturnTypeElement() != null && PsiTreeUtil.findChildrenOfType(method.getReturnTypeElement(), PsiJavaCodeReferenceElement.class).stream() + .anyMatch(reference -> reference.getQualifier() instanceof PsiJavaCodeReferenceElement qualifier && reference.resolve() == null && qualifier.resolve() == null); + } + + private static boolean isDeclarationName(PsiElement element) { + return element instanceof PsiIdentifier && element.getParent() instanceof PsiNameIdentifierOwner; + } + + private static Symbol symbol(JSema sema, PsiElement element) { + if (element instanceof PsiIdentifier) { + return symbol(sema, element.getParent()); + } + if (element instanceof PsiThisExpression || element instanceof PsiSuperExpression) { + var type = type(sema, element); + var qualifier = element instanceof PsiQualifiedExpression expression ? expression.getQualifier() : null; + var owner = qualifier instanceof PsiJavaCodeReferenceElement reference ? sema.symbol(reference.resolve()) + : sema.symbol(PsiTreeUtil.getParentOfType(element, PsiClass.class)); + return owner instanceof JTypeSymbol cls ? element instanceof PsiSuperExpression ? cls.superSymbol : cls.thisSymbol : Symbol.UNKNOWN_SYMBOL; + } + if (element instanceof PsiReferenceExpression reference && reference.getParent() instanceof PsiMethodCallExpression call) { + return sema.method(call); + } + if (element instanceof PsiReferenceExpression reference) { + var resolved = reference.advancedResolve(false); + if (resolved.isValidResult() && resolved.getElement() instanceof PsiField field) { + return sema.variable(field, resolved.getSubstitutor()); + } + } + if (element instanceof PsiTypeElement type) { + return sema.type(type.getType()).symbol(); + } + var target = target(sema, element); + if (target == null && element instanceof PsiJavaCodeReferenceElement reference && !(element instanceof PsiReferenceExpression)) { + return type(sema, reference).symbol(); + } + return target == null ? Symbol.UNKNOWN_SYMBOL : sema.symbol(target); + } + + private static PsiElement target(JSema sema, PsiElement element) { + if (element instanceof PsiIdentifier) { + var parent = element.getParent(); + if (parent instanceof PsiNameIdentifierOwner owner && owner.getNameIdentifier() == element) { + return parent; + } + return target(sema, parent); + } + if (element instanceof PsiJavaCodeReferenceElement reference) { + var result = reference.advancedResolve(false); + return result.isValidResult() || result.getElement() instanceof PsiPackage ? result.getElement() : null; + } + if (element instanceof PsiClass || element instanceof PsiVariable || element instanceof PsiMethod) { + return element; + } + return null; + } + + private static Type type(JSema sema, PsiElement element) { + if (element instanceof PsiIdentifier) { + return type(sema, element.getParent()); + } + if (element instanceof PsiExpression expression) { + if (expression instanceof PsiSwitchExpression && PsiTreeUtil.findChildrenOfType(expression, PsiYieldStatement.class).isEmpty() + && !PsiTreeUtil.findChildrenOfType(expression, PsiReturnStatement.class).isEmpty()) { + return Type.UNKNOWN; + } + if (expression instanceof PsiFunctionalExpression functional) { + return sema.type(functional.getFunctionalInterfaceType()); + } + var value = expression.getType(); + if (value == null && expression instanceof PsiReferenceExpression reference && reference.resolve() instanceof PsiClass cls) { + return sema.symbol(cls).type(); + } + return sema.type(value); + } + if (element instanceof PsiAnnotation annotation) { + return sema.symbol(annotation.resolveAnnotationType()).type(); + } + if (element instanceof PsiTypeElement type) { + return sema.type(type.getType()); + } + if (element instanceof PsiVariable variable) { + return sema.type(variable.getType()); + } + if (element instanceof PsiClass cls) { + return sema.symbol(cls).type(); + } + if (element instanceof PsiJavaCodeReferenceElement reference) { + return sema.type(JavaPsiFacade.getElementFactory(sema.project).createType(reference)); + } + if (element instanceof PsiTypeTestPattern pattern) { + return sema.type(pattern.getCheckType().getType()); + } + if (element instanceof PsiDeconstructionPattern pattern) { + return sema.type(pattern.getTypeElement().getType()); + } + if (element instanceof com.intellij.psi.PsiUnnamedPattern pattern) { + return sema.type(pattern.getTypeElement().getType()); + } + return Type.UNKNOWN; + } +} diff --git a/java-frontend/src/main/java/org/sonar/java/model/VisitorsBridge.java b/java-frontend/src/main/java/org/sonar/java/model/VisitorsBridge.java index bed0a6217a9..2491e26f53c 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/VisitorsBridge.java +++ b/java-frontend/src/main/java/org/sonar/java/model/VisitorsBridge.java @@ -29,6 +29,8 @@ import java.util.function.Predicate; import java.util.stream.StreamSupport; import javax.annotation.Nullable; +import org.apache.commons.lang3.exception.ExceptionUtils; +import org.eclipse.core.runtime.OperationCanceledException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.sonar.api.batch.fs.InputFile; @@ -290,7 +292,9 @@ private void runScanner(Runnable action, JavaFileScanner scanner) throws CheckFa throw new AnalysisException("Bad configuration of rule parameter", e); } catch (Exception e) { Throwable rootCause = ThrowableUtils.getRootCause(e); - if (rootCause instanceof InterruptedIOException + if (Thread.currentThread().isInterrupted() + || ExceptionUtils.getThrowableList(e).stream().anyMatch(OperationCanceledException.class::isInstance) + || rootCause instanceof InterruptedIOException || rootCause instanceof InterruptedException || rootCause instanceof CancellationException || analysisCancelled()) { diff --git a/java-frontend/src/main/java/org/sonar/java/model/expression/InstanceOfTreeImpl.java b/java-frontend/src/main/java/org/sonar/java/model/expression/InstanceOfTreeImpl.java index 07b7529ce84..fcc8d6c1e6e 100644 --- a/java-frontend/src/main/java/org/sonar/java/model/expression/InstanceOfTreeImpl.java +++ b/java-frontend/src/main/java/org/sonar/java/model/expression/InstanceOfTreeImpl.java @@ -88,9 +88,6 @@ public TypeTree type() { @Override public VariableTree variable() { if (pattern != null && pattern.is(Tree.Kind.TYPE_PATTERN)) { - // in practice, we can not have another type than a TYPE_PATTERN for a PATTERN_INSTANCE_OF tree. - // ECJ does not yet support the other patterns in this case, and so the variable will always be there. - // it's a bug, supposed to be fix by this PR: https://github.com/eclipse-jdt/eclipse.jdt.core/pull/437 return ((TypePatternTree) pattern).patternVariable(); } return null; diff --git a/java-frontend/src/main/java/org/sonar/plugins/java/api/semantic/Symbol.java b/java-frontend/src/main/java/org/sonar/plugins/java/api/semantic/Symbol.java index a88f3659bd4..8c883c7f200 100644 --- a/java-frontend/src/main/java/org/sonar/plugins/java/api/semantic/Symbol.java +++ b/java-frontend/src/main/java/org/sonar/plugins/java/api/semantic/Symbol.java @@ -250,7 +250,7 @@ default Object defaultValue() { * Use to access parameter annotations. Note: * 1) in case of generic types of method invocations, this list of types is less specialized than {@link #parameterTypes()}. * For example it could be T instead of String. - * 2) when the declaration comes from binaries, the name of the symbol will be generated (@see JVariableSymbol.ParameterPlaceholderSymbol). + * 2) when the declaration comes from binaries, the name of the symbol will be generated. * * @return empty list if methods has not parameters */ diff --git a/java-frontend/src/test/java/org/eclipse/jdt/core/dom/ASTUtilsTest.java b/java-frontend/src/test/java/org/eclipse/jdt/core/dom/ASTUtilsTest.java deleted file mode 100644 index 7e985fc8e8a..00000000000 --- a/java-frontend/src/test/java/org/eclipse/jdt/core/dom/ASTUtilsTest.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * SonarQube Java - * Copyright (C) SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * You can redistribute and/or modify this program under the terms of - * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.eclipse.jdt.core.dom; - -import org.junit.jupiter.api.Test; - -import static org.junit.jupiter.api.Assertions.assertNull; - -class ASTUtilsTest { - - @Test - void type_resolution_should_recover() { - assertNull(ASTUtils.resolveType(/* causes NPE */null, "Unknown")); - } -} diff --git a/java-frontend/src/test/java/org/sonar/java/JavaFrontendTest.java b/java-frontend/src/test/java/org/sonar/java/JavaFrontendTest.java index 368f9ed81aa..62d755a2ae2 100644 --- a/java-frontend/src/test/java/org/sonar/java/JavaFrontendTest.java +++ b/java-frontend/src/test/java/org/sonar/java/JavaFrontendTest.java @@ -607,6 +607,22 @@ void should_handle_analysis_cancellation_batch_mode(String propertyName, String assertThat(mainCodeIssueScannerAndFilter.endOfAnalysisInvocationCount).isEqualTo(1); } + @ParameterizedTest + @CsvSource({ + "sonar.java.experimental.batchModeSizeInKB,1000", + "sonar.internal.analysis.autoscan,true" + }) + void visitor_cancellation_does_not_retry_a_batch_callback(String propertyName, String propertyValue) { + mainCodeIssueScannerAndFilter.exceptionDuringScan = new OperationCanceledException("cancelled during visit"); + MapSettings settings = new MapSettings(); + settings.setProperty(propertyName, propertyValue); + assertThatThrownBy(() -> scan(settings, SONARQUBE_RUNTIME, "class A {}", "class B {}")) + .isInstanceOf(AnalysisException.class).hasMessage("Analysis cancelled").hasCauseInstanceOf(OperationCanceledException.class); + assertThat(mainCodeIssueScannerAndFilter.scanFileInvocationCount).isEqualTo(1); + assertThat(mainCodeIssueScannerAndFilter.endOfAnalysisInvocationCount).isEqualTo(1); + assertThat(logTester.logs(Level.WARN)).noneMatch(message -> message.contains("Fallback to file by file")); + } + @ParameterizedTest @CsvSource({ "sonar.java.experimental.batchModeSizeInKB,1000", @@ -854,6 +870,8 @@ public void scanFile(JavaFileScannerContext scannerContext) { this.scannerContext = scannerContext; scanFileInvocationCount++; lastScannedTree = scannerContext.getTree(); + String expectedSema = "JSema"; + assertThat(((org.sonar.java.model.JavaTree.CompilationUnitTreeImpl) lastScannedTree).sema.getClass().getSimpleName()).isEqualTo(expectedSema); if (isCancelled) { sensorContext.setCancelled(true); } diff --git a/java-frontend/src/test/java/org/sonar/java/ProgressMonitorTest.java b/java-frontend/src/test/java/org/sonar/java/ProgressMonitorTest.java index 3d5b0f76178..ef2f7ce9a82 100644 --- a/java-frontend/src/test/java/org/sonar/java/ProgressMonitorTest.java +++ b/java-frontend/src/test/java/org/sonar/java/ProgressMonitorTest.java @@ -19,7 +19,6 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; -import org.eclipse.core.runtime.IProgressMonitor; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout; import org.junit.jupiter.api.extension.RegisterExtension; @@ -218,7 +217,7 @@ void test_unknown_total_work() throws Exception { analysisProgress.startBatch(125); ProgressMonitor report = new ProgressMonitor(() -> false, logger, TimeUnit.MILLISECONDS.toMillis(250), analysisProgress); - report.beginTask("taskName", IProgressMonitor.UNKNOWN); + report.beginTask("taskName", -1); waitForMessage(logger); report.worked(250); diff --git a/java-frontend/src/test/java/org/sonar/java/ast/JavaAstScannerTest.java b/java-frontend/src/test/java/org/sonar/java/ast/JavaAstScannerTest.java index 935e20404f7..f8b5638058e 100644 --- a/java-frontend/src/test/java/org/sonar/java/ast/JavaAstScannerTest.java +++ b/java-frontend/src/test/java/org/sonar/java/ast/JavaAstScannerTest.java @@ -28,6 +28,7 @@ import java.util.List; import java.util.Map; import java.util.concurrent.CancellationException; +import org.eclipse.core.runtime.OperationCanceledException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -81,7 +82,7 @@ import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -import static org.sonar.java.model.EcjTestSupport.clearSymbol; +import static org.sonar.java.model.SemanticTestSupport.clearSymbol; @TestResourceScope.Scoped class JavaAstScannerTest { @@ -228,7 +229,8 @@ void java15SwitchExpression() { @ValueSource(classes = { InterruptedException.class, InterruptedIOException.class, - CancellationException.class}) + CancellationException.class, + OperationCanceledException.class}) void should_interrupt_analysis_when_specific_exception_are_thrown(Class exceptionClass) throws Exception { List inputFiles = Collections.singletonList(TestUtils.inputFile("src/test/files/metrics/NoSonar.java")); List visitors = Collections.singletonList(new CheckThrowingException( @@ -246,7 +248,8 @@ void should_interrupt_analysis_when_specific_exception_are_thrown(Class exceptionClass) throws Exception { List inputFiles = Collections.singletonList(TestUtils.inputFile("src/test/files/metrics/NoSonar.java")); List visitors = Collections.singletonList(new CheckThrowingException( @@ -260,6 +263,17 @@ void should_interrupt_analysis_when_specific_exception_are_thrown_as_batch(Class .hasCauseInstanceOf(RecognitionException.class); } + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void should_interrupt_analysis_when_cancellation_has_a_nested_cause(boolean batch) { + var canceled = new OperationCanceledException("cancelled"); + canceled.initCause(new IllegalStateException("cancellation context")); + var visitors = List.of(new CheckThrowingException(new RecognitionException(42, "interrupted", canceled))); + var files = List.of(TestUtils.inputFile("src/test/files/metrics/NoSonar.java")); + assertThatThrownBy(() -> scanFilesWithVisitors(files, visitors, -1, false, batch)) + .isInstanceOf(AnalysisException.class).hasMessage("Analysis cancelled").hasCauseInstanceOf(RecognitionException.class); + } + @Test void should_interrupt_analysis_when_is_cancelled() { List inputFiles = Collections.singletonList(TestUtils.inputFile("src/test/files/metrics/NoSonar.java")); diff --git a/java-frontend/src/test/java/org/sonar/java/model/ClassesLayoutTest.java b/java-frontend/src/test/java/org/sonar/java/model/ClassesLayoutTest.java index ebc0270a67c..94a858ec454 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/ClassesLayoutTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/ClassesLayoutTest.java @@ -91,27 +91,27 @@ void method_invocation() { @Test void type() { - assertThat(countFields(JType.class)).isEqualTo(7); + assertThat(countFields(JType.class)).isEqualTo(3); } @Test void symbol_type() { - assertThat(countFields(JTypeSymbol.class)).isEqualTo(11); + assertThat(countFields(JTypeSymbol.class)).isEqualTo(7); } @Test void symbol_method() { - assertThat(countFields(JMethodSymbol.class)).isEqualTo(11); + assertThat(countFields(JMethodSymbol.class)).isEqualTo(7); } @Test void symbol_variable() { - assertThat(countFields(JVariableSymbol.class)).isEqualTo(7); + assertThat(countFields(JVariableSymbol.class)).isEqualTo(6); } @Test - void annotation() { - assertThat(countFields(EcjSymbolMetadata.JAnnotationInstance.class)).isEqualTo(3); + void annotation() throws Exception { + assertThat(countFields(Class.forName("org.sonar.java.model.JSymbolMetadata$Annotation"))).isEqualTo(2); } /** Count number of fields in instances, including inherited fields. */ diff --git a/java-frontend/src/test/java/org/sonar/java/model/EcjTestSupport.java b/java-frontend/src/test/java/org/sonar/java/model/EcjTestSupport.java deleted file mode 100644 index 353ed595c70..00000000000 --- a/java-frontend/src/test/java/org/sonar/java/model/EcjTestSupport.java +++ /dev/null @@ -1,77 +0,0 @@ -/* - * SonarQube Java - * Copyright (C) SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * You can redistribute and/or modify this program under the terms of - * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.java.model; - -import org.eclipse.jdt.core.dom.IBinding; -import org.eclipse.jdt.core.dom.IMethodBinding; -import org.eclipse.jdt.core.dom.ITypeBinding; -import org.eclipse.jdt.core.dom.IVariableBinding; -import org.sonar.java.model.declaration.ClassTreeImpl; -import org.sonar.java.model.declaration.VariableTreeImpl; -import org.sonar.java.model.expression.IdentifierTreeImpl; -import org.sonar.plugins.java.api.tree.CompilationUnitTree; - -public final class EcjTestSupport { - - private EcjTestSupport() { - } - - public static JSema sema(CompilationUnitTree tree) { - return (JSema) ((JavaTree.CompilationUnitTreeImpl) tree).sema; - } - - public static ITypeBinding typeBinding(Object tree) { - return EcjTreeBindings.typeBinding(tree); - } - - public static IMethodBinding methodBinding(Object tree) { - return EcjTreeBindings.methodBinding(tree); - } - - public static IVariableBinding variableBinding(VariableTreeImpl tree) { - return EcjTreeBindings.variableBinding(tree); - } - - public static IBinding binding(Object tree) { - return EcjTreeBindings.binding(tree); - } - - public static void clearType(JavaTree tree) { - if (tree instanceof AbstractTypedTree typed) { - typed.type = SemanticValues.UNKNOWN_TYPE; - } else if (tree instanceof ClassTreeImpl cls) { - cls.typeSymbol = SemanticValues.UNKNOWN_TYPE_SYMBOL; - } else if (tree instanceof TypeParameterTreeImpl parameter) { - parameter.typeSymbol = SemanticValues.UNKNOWN_SYMBOL; - } else { - throw new IllegalArgumentException("No type attachment: " + tree.getClass()); - } - if (tree instanceof KeywordThis || tree instanceof KeywordSuper) { - ((IdentifierTreeImpl) tree).symbolSupplier = SemanticValues.UNKNOWN_SYMBOL; - } - } - - public static void clearSymbol(JavaTree tree) { - if (tree instanceof IdentifierTreeImpl identifier) { - identifier.symbolSupplier = SemanticValues.UNKNOWN_SYMBOL; - } else if (tree instanceof VariableTreeImpl variable) { - variable.variableSymbol = SemanticValues.UNKNOWN_SYMBOL; - } else { - throw new IllegalArgumentException("No symbol attachment: " + tree.getClass()); - } - } -} diff --git a/java-frontend/src/test/java/org/sonar/java/model/FrontendLifecycleTest.java b/java-frontend/src/test/java/org/sonar/java/model/FrontendLifecycleTest.java index bc19ff260b7..c083508ffcd 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/FrontendLifecycleTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/FrontendLifecycleTest.java @@ -214,8 +214,8 @@ void callback_error_preserves_primary_when_close_fails() { } @Test - void ecj_registers_environment_before_syntax_conversion_failure() { - FrontendSession session = spy(new EcjFrontendBackend(() -> EcjFrontendBackend.newParser(CONFIGURATION)).open(CONFIGURATION)); + void psi_registers_environment_before_syntax_conversion_failure() { + FrontendSession session = spy(new PsiFrontendBackend().open(CONFIGURATION)); try (session) { assertThatThrownBy(() -> session.parse("A.java", "class A { void m( }")) .isInstanceOf(com.sonar.sslr.api.RecognitionException.class); diff --git a/java-frontend/src/test/java/org/sonar/java/model/JMethodSymbolTest.java b/java-frontend/src/test/java/org/sonar/java/model/JMethodSymbolTest.java index bae9e77a15e..29006f1c932 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JMethodSymbolTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JMethodSymbolTest.java @@ -21,8 +21,6 @@ import java.util.Collection; import java.util.List; import java.util.Objects; -import org.eclipse.jdt.core.dom.IMethodBinding; -import org.eclipse.jdt.core.dom.ITypeBinding; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.sonar.api.batch.fs.InputFile; @@ -47,14 +45,12 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatCode; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; -import static org.sonar.java.model.EcjTestSupport.methodBinding; -import static org.sonar.java.model.EcjTestSupport.sema; import static org.sonar.java.model.JUtilsTest.firstClass; import static org.sonar.java.model.JUtilsTest.firstMethod; import static org.sonar.java.model.JUtilsTest.nthMethod; @@ -126,16 +122,14 @@ void test_declaration_not_in_code() { Symbol symbolParam1 = symbol1.declarationParameters().get(0); Symbol symbolParam2 = symbol2.declarationParameters().get(0); - assertThat(symbolParam1).isInstanceOf(JVariableSymbol.ParameterPlaceholderSymbol.class) - .isInstanceOf(Symbol.VariableSymbol.class); - assertThat(symbolParam2).isInstanceOf(JVariableSymbol.ParameterPlaceholderSymbol.class) - .isInstanceOf(Symbol.VariableSymbol.class); + assertThat(symbolParam1).isInstanceOf(Symbol.VariableSymbol.class); + assertThat(symbolParam2).isInstanceOf(Symbol.VariableSymbol.class); assertThat(symbolParam1.isVariableSymbol()).isTrue(); assertThat(symbolParam2.isVariableSymbol()).isTrue(); - JVariableSymbol.ParameterPlaceholderSymbol parameterSymbol1 = (JVariableSymbol.ParameterPlaceholderSymbol) symbolParam1; - JVariableSymbol.ParameterPlaceholderSymbol parameterSymbol2 = (JVariableSymbol.ParameterPlaceholderSymbol) symbolParam2; + Symbol.VariableSymbol parameterSymbol1 = (Symbol.VariableSymbol) symbolParam1; + Symbol.VariableSymbol parameterSymbol2 = (Symbol.VariableSymbol) symbolParam2; assertThat(parameterSymbol1).isSameAs(parameterSymbol2); @@ -197,7 +191,7 @@ void testSingleInheritance() { + "class Clazz implements A { public void a() {} }"); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(1); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - JMethodSymbol symbol = sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(m))); + Symbol.MethodSymbol symbol = Objects.requireNonNull(SemanticTestSupport.method(m)); assertThat(symbol.overriddenSymbols()).containsOnly(retrieveMethodSymbol("A", "a", cu)); } @@ -212,7 +206,7 @@ class C extends B { public void a() {} } """); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(3); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - JMethodSymbol symbol = sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(m))); + Symbol.MethodSymbol symbol = Objects.requireNonNull(SemanticTestSupport.method(m)); assertThat(symbol.overriddenSymbols()).containsExactly( retrieveMethodSymbol("B", "a", cu), @@ -225,9 +219,9 @@ void testObjectExtensionFromClass() { JavaTree.CompilationUnitTreeImpl cu = test("class Clazz { public boolean equals(Object other) { return false; } }"); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - JMethodSymbol symbol = sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(m))); + Symbol.MethodSymbol symbol = Objects.requireNonNull(SemanticTestSupport.method(m)); - assertThat(symbol.overriddenSymbols()).containsExactly(objectEqualsMethod(sema(cu))); + assertThat(symbol.overriddenSymbols()).containsExactly(objectEqualsMethod(cu.sema)); } @Test @@ -235,17 +229,14 @@ void testObjectExtensionFromInterface() { JavaTree.CompilationUnitTreeImpl cu = test("interface Interface { boolean equals(Object other) { return false; } }"); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - JMethodSymbol symbol = sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(m))); + Symbol.MethodSymbol symbol = Objects.requireNonNull(SemanticTestSupport.method(m)); - assertThat(symbol.overriddenSymbols()).containsExactly(objectEqualsMethod(sema(cu))); + assertThat(symbol.overriddenSymbols()).containsExactly(objectEqualsMethod(cu.sema)); } - private static JMethodSymbol objectEqualsMethod(JSema sema) { - return Arrays.stream(sema.resolveType("java.lang.Object").getDeclaredMethods()) - .filter(method -> "equals".equals(method.getName())) - .findFirst() - .map(sema::methodSymbol) - .orElseThrow(() -> new IllegalStateException("Could not find Object#equals")); + private static Symbol.MethodSymbol objectEqualsMethod(org.sonar.plugins.java.api.semantic.Sema sema) { + return sema.getClassType("java.lang.Object").symbol().lookupSymbols("equals").stream() + .map(Symbol.MethodSymbol.class::cast).findFirst().orElseThrow(); } @Test @@ -257,7 +248,7 @@ class C implements A, B { public void a() { } } """); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(2); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - JMethodSymbol symbol = sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(m))); + Symbol.MethodSymbol symbol = Objects.requireNonNull(SemanticTestSupport.method(m)); assertThat(symbol.overriddenSymbols()).containsExactly( retrieveMethodSymbol("A", "a", cu), @@ -271,7 +262,7 @@ void testUnknownInheritance() { + "class C implements KnownInterface, UnknownInterface { public void a() { } }"); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(1); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - JMethodSymbol symbol = sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(m))); + Symbol.MethodSymbol symbol = Objects.requireNonNull(SemanticTestSupport.method(m)); assertThat(symbol.overriddenSymbols()).containsExactly( retrieveMethodSymbol("KnownInterface", "a", cu)); @@ -283,30 +274,21 @@ void testUnknownExtends() { + "class B extends Unknown { public void a() { } }"); ClassTreeImpl a = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) a.members().get(0); - JMethodSymbol symbol = sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(m))); + Symbol.MethodSymbol symbol = Objects.requireNonNull(SemanticTestSupport.method(m)); assertThat(symbol.overriddenSymbols()).isEmpty(); } @Test void testBindingReturnNullSuperClass() { - JavaTree.CompilationUnitTreeImpl cu = test("" - + "class A { public void a() { } }"); - ClassTreeImpl a = (ClassTreeImpl) cu.types().get(0); - MethodTreeImpl m = (MethodTreeImpl) a.members().get(0); - // We create a real JMethodSymbol because it is not possible to mock JMethodSymbol (it is final), and not easy - // to mock the arguments either, because the constructor is using an external helper method. - JMethodSymbol symbol = sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(m))); - - ITypeBinding iTypeBinding = mock(ITypeBinding.class); - // In some rare situation, the "getSuperclass" can return null. It is not easy to write code reproducing the issue, we test it by "hand". - when(iTypeBinding.getSuperclass()).thenReturn(null); - ITypeBinding[] interfaces = {null}; - when(iTypeBinding.getInterfaces()).thenReturn(interfaces); - - Collection overrides = new ArrayList<>(); - assertDoesNotThrow(() -> - symbol.findOverridesInParentTypes(overrides, methodBinding -> false, iTypeBinding)); - assertThat(overrides).isEmpty(); + var cu = test("class A { public void a() { } }"); + var original = (JMethodSymbol) ((MethodTreeImpl) ((ClassTreeImpl) cu.types().getFirst()).members().getFirst()).symbol(); + var owner = spy(original.method.getContainingClass()); + when(owner.getSuperClass()).thenReturn(null); + when(owner.getSuperTypes()).thenReturn(new com.intellij.psi.PsiClassType[] {null}); + var method = spy(original.method); + when(method.getContainingClass()).thenReturn(owner); + var symbol = new JMethodSymbol((JSema) cu.sema, method, original.substitutor, null, original.key); + assertThat(assertDoesNotThrow(symbol::overriddenSymbols)).isEmpty(); } @Test @@ -319,15 +301,15 @@ class Clazz implements A, C { public boolean equals(Object other) { return false """); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(3); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - JMethodSymbol symbol = sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(m))); + Symbol.MethodSymbol symbol = Objects.requireNonNull(SemanticTestSupport.method(m)); assertThat(symbol.overriddenSymbols()).containsExactly( - objectEqualsMethod(sema(cu)), + objectEqualsMethod(cu.sema), retrieveMethodSymbol("A", "equals", cu), retrieveMethodSymbol("B", "equals", cu)); } - private static JMethodSymbol retrieveMethodSymbol(String className, String methodName, CompilationUnitTreeImpl cu) { + private static Symbol.MethodSymbol retrieveMethodSymbol(String className, String methodName, CompilationUnitTreeImpl cu) { MethodMatchers methodMatcher = MethodMatchers.create() .ofTypes(className) .names(methodName) @@ -340,7 +322,7 @@ private static JMethodSymbol retrieveMethodSymbol(String className, String metho .map(Symbol.TypeSymbol::memberSymbols) .flatMap(Collection::stream) .filter(methodMatcher::matches) - .map(JMethodSymbol.class::cast) + .map(Symbol.MethodSymbol.class::cast) .findFirst() .orElseThrow(() -> new IllegalStateException("No method could be found with the given name in the given class")); } @@ -353,20 +335,20 @@ void signature() { MethodTreeImpl method = (MethodTreeImpl) c.members().get(1); ReturnStatementTreeImpl s = (ReturnStatementTreeImpl) Objects.requireNonNull(method.block()).body().get(0); MethodInvocationTreeImpl methodInvocation = Objects.requireNonNull((MethodInvocationTreeImpl) s.expression()); - assertThat(sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(constructor))).signature()) + assertThat(Objects.requireNonNull(SemanticTestSupport.method(constructor)).signature()) .isEqualTo(constructor.symbol().signature()) .isEqualTo("org.example.C#()V"); - assertThat(sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(method))).signature()) + assertThat(Objects.requireNonNull(SemanticTestSupport.method(method)).signature()) .isEqualTo(method.symbol().signature()) .isEqualTo("org.example.C#m(Ljava/lang/Object;[Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); - assertThat(sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(methodInvocation))).signature()) + assertThat(Objects.requireNonNull(SemanticTestSupport.method(methodInvocation)).signature()) .isEqualTo(method.symbol().signature()) .isEqualTo("org.example.C#m(Ljava/lang/Object;[Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); } @Test void isOverridableTest(){ - JMethodSymbol jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); + Symbol.MethodSymbol jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); assertThat(jms.isOverridable()).isTrue(); jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }", true); assertThat(jms.isOverridable()).isFalse(); @@ -382,7 +364,7 @@ void isOverridableTest(){ @Test void isParametrizedMethodTest(){ - JMethodSymbol jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); + Symbol.MethodSymbol jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); assertThat(jms.isParametrizedMethod()).isFalse(); jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); assertThat(jms.isParametrizedMethod()).isTrue(); @@ -394,7 +376,7 @@ void isParametrizedMethodTest(){ @Test void isDefaultMethodTest(){ - JMethodSymbol jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); + Symbol.MethodSymbol jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); assertThat(jms.isDefaultMethod()).isFalse(); jms = getJMethodSymbolFromClassText("interface I { default C m() { return null; } }"); assertThat(jms.isDefaultMethod()).isTrue(); @@ -404,7 +386,7 @@ void isDefaultMethodTest(){ @Test void isSynchronizedMethodTest(){ - JMethodSymbol jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); + Symbol.MethodSymbol jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); assertThat(jms.isSynchronizedMethod()).isFalse(); jms = getJMethodSymbolFromClassText("class C { synchronized C m() { return null; } }"); assertThat(jms.isSynchronizedMethod()).isTrue(); @@ -414,7 +396,7 @@ void isSynchronizedMethodTest(){ @Test void isVarArgsTest(){ - JMethodSymbol jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); + Symbol.MethodSymbol jms = getJMethodSymbolFromClassText("class C { C m() { return null; } }"); assertThat(jms.isVarArgsMethod()).isFalse(); jms = getJMethodSymbolFromClassText("class C { C m(String... s) { return null; } }"); assertThat(jms.isVarArgsMethod()).isTrue(); @@ -423,17 +405,15 @@ void isVarArgsTest(){ } @Test - void support_unexpected_IMethodBinding_null_return_type() { - JavaTree.CompilationUnitTreeImpl cu = test("class C { C m() { return null; } }"); - ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); - MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - // simulate broken semantic with getReturnType() == null - IMethodBinding brokenMethodBinding = spy(methodBinding(m)); - when(brokenMethodBinding.getReturnType()).thenReturn(null); - JMethodSymbol methodSymbol = new JMethodSymbol(sema(cu), brokenMethodBinding); - assertThat(methodSymbol.returnType().isUnknown()).isTrue(); - assertThat(methodSymbol.isNativeMethod()).isFalse(); - assertThat(methodSymbol.metadata()).isSameAs(Symbols.EMPTY_METADATA); + void support_unexpected_method_null_return_type() { + var cu = test("class C { C m() { return null; } }"); + var original = (JMethodSymbol) ((MethodTreeImpl) ((ClassTreeImpl) cu.types().getFirst()).members().getFirst()).symbol(); + var method = spy(original.method); + when(method.getReturnType()).thenReturn(null); + var symbol = new JMethodSymbol((JSema) cu.sema, method, original.substitutor, null, original.key); + assertThat(symbol.returnType().isUnknown()).isTrue(); + assertThat(symbol.isNativeMethod()).isFalse(); + assertThat(symbol.metadata().annotations()).isEmpty(); } @Test @@ -451,25 +431,22 @@ public static void f() { MethodTreeImpl m = (MethodTreeImpl) c.members().get(1); ExpressionStatementTree statementTree = ((ExpressionStatementTreeImpl) m.block().body().get(0)); NewClassTreeImpl newClassExpression = ((NewClassTreeImpl) statementTree.expression()); - JMethodSymbol symbol = ((JMethodSymbol) newClassExpression.methodSymbol()); + Symbol.MethodSymbol symbol = ((Symbol.MethodSymbol) newClassExpression.methodSymbol()); assertThat(symbol.declarationParameters()).hasSize(6); } - private static JMethodSymbol getJMethodSymbolFromClassText(String classText){ + private static Symbol.MethodSymbol getJMethodSymbolFromClassText(String classText){ return getJMethodSymbolFromClassText(classText, false); } - private static JMethodSymbol getJMethodSymbolFromClassText(String classText, boolean brokenSemantic){ + private static Symbol.MethodSymbol getJMethodSymbolFromClassText(String classText, boolean brokenSemantic){ JavaTree.CompilationUnitTreeImpl cu = test(classText); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - if(brokenSemantic){ - IMethodBinding brokenMethodBinding = spy(methodBinding(m)); - when(brokenMethodBinding.getReturnType()).thenReturn(null); - when(brokenMethodBinding.isRecovered()).thenReturn(true); - return new JMethodSymbol(sema(cu), brokenMethodBinding); + if (brokenSemantic) { + return Symbol.MethodSymbol.UNKNOWN_METHOD; } - return new JMethodSymbol(sema(cu), methodBinding(m)); + return m.symbol(); } private static CompilationUnitTreeImpl test(String source) { @@ -515,14 +492,14 @@ void foo() { } ClassTreeImpl a = firstClass(cu); MethodTreeImpl foo = firstMethod(a); - var fooSymbol = (JMethodSymbol) foo.symbol(); - assertFalse(fooSymbol.isLambda()); + var fooSymbol = foo.symbol(); + assertFalse(SemanticTestSupport.isLambda(fooSymbol)); assertThat(fooSymbol.toString()).isNotEmpty(); var barAssignment = (VariableTree) a.members().get(1); var initializer = (LambdaExpressionTree) barAssignment.initializer(); - var lambdaSymbol = (JMethodSymbol) initializer.symbol(); - assertTrue(lambdaSymbol.isLambda()); + var lambdaSymbol = initializer.symbol(); + assertTrue(SemanticTestSupport.isLambda(lambdaSymbol)); assertThat(lambdaSymbol.toString()).isNotEmpty(); } } diff --git a/java-frontend/src/test/java/org/sonar/java/model/JParserConfigTest.java b/java-frontend/src/test/java/org/sonar/java/model/JParserConfigTest.java index 78d488f74b7..503e14440c8 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JParserConfigTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JParserConfigTest.java @@ -23,12 +23,30 @@ import org.sonar.java.testing.ThreadLocalLogTester; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.sonar.java.model.JParserConfig.shouldEnablePreviewFlag; class JParserConfigTest { @RegisterExtension public ThreadLocalLogTester logTester = new ThreadLocalLogTester().setLevel(Level.INFO); + @Test + void psi_is_the_only_frontend_even_with_legacy_selection_properties() { + String previous = System.getProperty("sonar.java.frontend"); + try { + for (String value : java.util.List.of("ecj", "psi", "invalid")) { + System.setProperty("sonar.java.frontend", value); + assertThat(JParserConfig.Mode.BATCH.create(new JavaVersionImpl(21), Collections.emptyList()).backend()).isInstanceOf(PsiFrontendBackend.class); + } + } finally { + if (previous == null) { + System.clearProperty("sonar.java.frontend"); + } else { + System.setProperty("sonar.java.frontend", previous); + } + } + } + @Test void should_enable_preview() { assertThat(shouldEnablePreviewFlag(new JavaVersionImpl())).isFalse(); diff --git a/java-frontend/src/test/java/org/sonar/java/model/JParserConversionTest.java b/java-frontend/src/test/java/org/sonar/java/model/JParserConversionTest.java new file mode 100644 index 00000000000..3a44f99a72c --- /dev/null +++ b/java-frontend/src/test/java/org/sonar/java/model/JParserConversionTest.java @@ -0,0 +1,176 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import java.util.EnumSet; +import java.util.Set; +import java.util.stream.Stream; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.sonar.java.test.TestResourceScope; +import org.sonar.plugins.java.api.tree.ArrayTypeTree; +import org.sonar.plugins.java.api.tree.ClassTree; +import org.sonar.plugins.java.api.tree.LiteralTree; +import org.sonar.plugins.java.api.tree.MethodTree; +import org.sonar.plugins.java.api.tree.ReturnStatementTree; +import org.sonar.plugins.java.api.tree.SwitchExpressionTree; +import org.sonar.plugins.java.api.tree.Tree; +import org.sonar.plugins.java.api.tree.VariableTree; + +import static org.assertj.core.api.Assertions.assertThat; + +@TestResourceScope.Scoped +class JParserConversionTest { + private static final Set COVERED = EnumSet.noneOf(Tree.Kind.class); + + @ParameterizedTest(name = "{0}") + @MethodSource("sources") + void syntax_contract(String name, String unitName, String source) { + var actual = PsiSyntaxTestSupport.parse(unitName, source); + PsiSyntaxTestSupport.assertStructure(actual, source); + COVERED.addAll(PsiSyntaxTestSupport.kinds(actual)); + } + + @AfterAll + static void every_syntax_kind_is_exercised() { + var expected = EnumSet.allOf(Tree.Kind.class); + expected.remove(Tree.Kind.OTHER); + assertThat(COVERED).containsExactlyInAnyOrderElementsOf(expected); + } + + @Test + void variable_groups_preserve_names_dimensions_and_initializers() { + var tree = PsiSyntaxTestSupport.parse("C.java", "class C { int first=1, second[]=null; void run() { int x=2,y=3; } }"); + var type = (ClassTree) tree.types().getFirst(); + assertThat(type.members()).hasSize(3); + var first = (VariableTree) type.members().get(0); + var second = (VariableTree) type.members().get(1); + assertThat(first.simpleName().name()).isEqualTo("first"); + assertThat(first.type().kind()).isEqualTo(Tree.Kind.PRIMITIVE_TYPE); + assertThat(((LiteralTree) first.initializer()).value()).isEqualTo("1"); + assertThat(second.simpleName().name()).isEqualTo("second"); + assertThat(second.type()).isInstanceOf(ArrayTypeTree.class); + assertThat(second.initializer().kind()).isEqualTo(Tree.Kind.NULL_LITERAL); + var statements = ((MethodTree) type.members().get(2)).block().body(); + assertThat(statements).hasSize(2); + assertThat(statements.stream().map(VariableTree.class::cast).map(variable -> variable.simpleName().name())) + .containsExactly("x", "y"); + } + + @Test + void receiver_parameters_do_not_become_ordinary_parameters() { + var tree = PsiSyntaxTestSupport.parse("C.java", "class C { void run(C this, int value) {} }"); + var method = (MethodTree) ((ClassTree) tree.types().getFirst()).members().getFirst(); + assertThat(method.parameters()).extracting(parameter -> parameter.simpleName().name()).containsExactly("value"); + } + + @Test + void empty_declarations_preserve_trailing_semicolons() { + var tree = PsiSyntaxTestSupport.parse("C.java", ";; class C {;; int value;; void run() {};;};;"); + assertThat(tree.types()).extracting(Tree::kind).containsExactly(Tree.Kind.CLASS, Tree.Kind.EMPTY_STATEMENT, Tree.Kind.EMPTY_STATEMENT); + assertThat(((ClassTree) tree.types().getFirst()).members()).extracting(Tree::kind) + .containsExactly(Tree.Kind.EMPTY_STATEMENT, Tree.Kind.EMPTY_STATEMENT, Tree.Kind.VARIABLE, Tree.Kind.EMPTY_STATEMENT, Tree.Kind.METHOD, Tree.Kind.EMPTY_STATEMENT, Tree.Kind.EMPTY_STATEMENT); + } + + @Test + void records_keep_components_and_the_compact_constructor() { + var tree = PsiSyntaxTestSupport.parse("R.java", "record R(T value, int... counts) { R { if(value == null) throw new IllegalArgumentException(); } }"); + var type = (ClassTree) tree.types().getFirst(); + assertThat(type.kind()).isEqualTo(Tree.Kind.RECORD); + assertThat(type.recordComponents()).extracting(component -> component.simpleName().name()).containsExactly("value", "counts"); + assertThat(type.recordComponents().get(1).type()).isInstanceOf(ArrayTypeTree.class); + assertThat(type.members()).hasSize(1); + assertThat(((MethodTree) type.members().getFirst()).block().body()).extracting(Tree::kind).containsExactly(Tree.Kind.IF_STATEMENT); + } + + @Test + void switch_rules_keep_multiple_labels_and_yield_blocks() { + var tree = PsiSyntaxTestSupport.parse("C.java", "class C { int run(int value) { return switch(value) { case 1,2 -> 3; default -> { yield 4; } }; } }"); + var method = (MethodTree) ((ClassTree) tree.types().getFirst()).members().getFirst(); + var expression = (SwitchExpressionTree) ((ReturnStatementTree) method.block().body().getFirst()).expression(); + assertThat(expression.cases()).hasSize(2); + var first = expression.cases().get(0).labels().getFirst(); + assertThat(first.isFallThrough()).isFalse(); + assertThat(first.expressions()).extracting(value -> ((LiteralTree) value).value()).containsExactly("1", "2"); + assertThat(expression.cases().get(1).body()).extracting(Tree::kind).containsExactly(Tree.Kind.BLOCK); + } + + static Stream sources() { + String unicode = "\\" + "u"; + return Stream.of( + sample("empty", ""), + sample("ordinary instanceof", "class A { boolean m(Object x){return x instanceof String;} }"), + sample("annotation declaration tokens", "@A(B.class) public @interface C {}"), + sample("qualified new with construction qualifier", "class A { Object x=new A().new B(); }"), + sample("all literals", "class A { Object[] x={1,2L,3.0f,4.0d,true,false,'x',\"x\",null}; String s=\"\"\"\n x\n \"\"\"; }"), + sample("empty enum", "enum A {; int x;}"), + sample("inferred declarations", "class A { void m(){var x=1;for(var y:xs){} try(var _=new A()){}catch(E _){} } }"), + sample("receiver parameters", "class A { void m(A this,int x){} class B { B(A A.this){} } }"), + sample("wildcards and primitive types", "class A{ X x; boolean b; byte c; char d; short e; int f; long g; float h; double i; }"), + sample("remaining operators", "class A { Object[] x={a--, ++a, --a, +a, -a, a-b, a<>>b, ab,a<=b,a>=b}; }"), + sample("unicode spelling", "cl" + unicode + "0061ss A { int " + unicode + "0078 = 1; void m(){ " + unicode + "0078++; } }"), + sample("generic closer whitespace", "class A { X x; X y; X /*e*/ > z; }"), + sample("generic closer comments", "class A { X> x; X y; int m(){return a >>> b;} }"), + sample("trivia", "/*before*/ class A {} // eof"), + sample("line endings", "class A {\r\n\tint x;\r String y;\n}"), + sample("markdown", "/// first\n/// second\nclass A {}"), + Arguments.of("package annotations", "package-info.java", "@Deprecated package a.b;"), + sample("imports", "package a; import a.B; import static a.B.c; import a.*; import static a.B.*; class C {}"), + sample("module import", "import module java.base; class A {}"), + Arguments.of("module directives", "module-info.java", "@Deprecated open module a.b { requires static transitive c.d; exports a.b to c.d, e.f; opens x.y; uses a.B; provides a.B with c.D, e.F; }"), + sample("empty declarations", ";; class A {;; int x;; void m() {};;};;"), + sample("type parameters", "class A<@B T extends a.B & C, U> { V m(V v) throws E, F { return v; } }"), + sample("qualified annotated types", "class A { a.@B C<@D ? extends E>.@F G field; }"), + sample("nested generic closers", "class A { X>> value; void m() { a.>>call(); } }"), + sample("annotated dimensions", "class A { @B int @C [] @D [] x @E [], y @F []; void m(int @G ... args) {} }"), + sample("variable groups", "class A { final int a=1,b=2; void m() { int x=1,y[]=null,z; for(int i=0,j=1;i<3;i++,j--){} } }"), + sample("annotation members", "@interface A { String value() default \"x\"; int[] x() default {1,2,}; B nested() default @B(x=1); }"), + sample("annotations", "@A({@B(x=1), @B(x=2)}) class C { @D(E.class) int x; }"), + sample("initializers", "class A { { int x=1; } static { int y=2; } A(){} A(int x){this();} }"), + sample("enums", "enum A { @B X, Y(1) { void m(){} }, Z(); int x; A(){} A(int n){} }"), + sample("records", "record A(@B T x, int... y) implements C { A { if(x==null)throw new E(); } A(T x){this(x,1);} }"), + sample("sealed declarations", "sealed interface A permits B,C {} final class B implements A {} non-sealed class C implements A {}"), + sample("local and anonymous classes", "class A { void m(){class B{} Object x=new a.B(1){int y; void n(){}};} }"), + sample("qualified construction", "class A { Object m(){ return outer.new Inner(1); } }"), + sample("operators", "class A { int m(int a,int b){a+=b; a>>>=1; return ((a+b)*2>>1)^(~a&b)|a/b%2;} }"), + sample("assignments", "class A { void m(){a=b=1; a-=1;a*=2;a/=2;a%=2;a&=2;a|=2;a^=2;a<<=2;a>>=2;} }"), + sample("conditional", "class A { boolean m(){ return a && b || !c ? x == y : x != y; } }"), + sample("casts", "class A { Object m(){ return (A & B & C) value; } }"), + sample("arrays", "class A { int[][] m(){int[][] a={{1,2},{3,4},}; a[0][1]++; return new int[2][];} }"), + sample("annotated new arrays", "class A { Object x=new @B String @C [] @D [] {{\"x\"}}; Object y=new int @E [1] @F [2]; }"), + sample("calls and keywords", "class A { A(){this(1);} A(int x){outer.super();} void m(){this.m();super.m();Outer.super.m();Outer.this.m();} }"), + sample("class literals and references", "class A { Object[] x={int.class, String[].class, A::new, int[]::new, a::m, A::m, super::m, A.super::m}; }"), + sample("lambdas", "class A { Object[] x={a->a, (a,b)->a+b, ()->{return 1;}, (@B var x, var y)->x, (String... args)->args}; }"), + sample("loops and labels", "class A { void m(){outer:for(;;){for(String x:xs){if(x==null)continue outer;else break;}do{x++;}while(x<3);while(x>0)x--;break outer;}} }"), + sample("try and resources", "class A { void m(){try(A x=new A();B y=new B();ref;){throw new E();}catch(E|F|G e){assert x:y;}finally{synchronized(this){}}} }"), + sample("switch groups", "class A { void m(){switch(x){case 0:case 1:x++;break;case 2,3:x--;default:;}} }"), + sample("switch rules", "class A { int m(){return switch(x){case 1,2->3;case 4->{yield 5;}default->throw new E();};} }"), + sample("patterns and guards", "class A { int m(Object x){return switch(x){case R(String s, R(int i, _)) when i>0 -> i;case null,default->0;};} }"), + sample("instanceof patterns", "class A { boolean m(Object x){return x instanceof R(String s, int _) || x instanceof String t || x instanceof int i;} }"), + sample("flexible constructors", "class A extends B { A(int x){int y=x; if(y<0)throw new E();super(y);} }"), + sample("compact source", "int value=1; void main(){System.out.println(value);}"), + sample("supplementary identifiers", "class A { int 𐐀; String s=\"😀\"; }") + ); + } + + private static Arguments sample(String name, String source) { + return Arguments.of(name, "File.java", source); + } +} diff --git a/java-frontend/src/test/java/org/sonar/java/model/JParserSemanticTest.java b/java-frontend/src/test/java/org/sonar/java/model/JParserSemanticTest.java index e4e6822f61d..a65e37d4d33 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JParserSemanticTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JParserSemanticTest.java @@ -21,16 +21,6 @@ import java.util.Map; import java.util.Objects; import java.util.Optional; -import org.eclipse.jdt.core.JavaCore; -import org.eclipse.jdt.core.dom.AST; -import org.eclipse.jdt.core.dom.ASTParser; -import org.eclipse.jdt.core.dom.Block; -import org.eclipse.jdt.core.dom.CompilationUnit; -import org.eclipse.jdt.core.dom.IBinding; -import org.eclipse.jdt.core.dom.ITypeBinding; -import org.eclipse.jdt.core.dom.MethodDeclaration; -import org.eclipse.jdt.core.dom.SwitchStatement; -import org.eclipse.jdt.core.dom.TypeDeclaration; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; @@ -96,17 +86,15 @@ import org.sonar.plugins.java.api.tree.YieldStatementTree; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertNotEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.mock; -import static org.sonar.java.model.EcjTestSupport.binding; -import static org.sonar.java.model.EcjTestSupport.clearSymbol; -import static org.sonar.java.model.EcjTestSupport.clearType; -import static org.sonar.java.model.EcjTestSupport.methodBinding; -import static org.sonar.java.model.EcjTestSupport.sema; -import static org.sonar.java.model.EcjTestSupport.typeBinding; -import static org.sonar.java.model.EcjTestSupport.variableBinding; +import static org.sonar.java.model.SemanticTestSupport.symbol; +import static org.sonar.java.model.SemanticTestSupport.clearSymbol; +import static org.sonar.java.model.SemanticTestSupport.clearType; +import static org.sonar.java.model.SemanticTestSupport.method; +import static org.sonar.java.model.SemanticTestSupport.type; import static org.sonar.java.model.assertions.TreeAssert.assertThat; import static org.sonar.java.model.assertions.TypeAssert.assertThat; @@ -139,32 +127,30 @@ void should_not_throw_RecognitionException_in_case_of_non_syntax_errors() { @Test void expression_null_literal() { AbstractTypedTree e = (AbstractTypedTree) expression("null"); - assertThat(typeBinding(e)).isNotNull(); + assertThat(type(e)).isNotNull(); } @Test void expression_literal() { InternalPrefixUnaryExpression e = (InternalPrefixUnaryExpression) expression("-2147483648"); // Integer.MIN_VALUE - assertThat(typeBinding(e)).isNotNull(); + assertThat(type(e)).isNotNull(); AbstractTypedTree t = (AbstractTypedTree) e.expression(); - assertThat(typeBinding(t)) + assertThat(type(t)) .isNotNull() - .isSameAs(typeBinding(e)); + .isSameAs(type(e)); } /** - * @see org.eclipse.jdt.core.dom.InfixExpression#extendedOperands() */ @Test void extended_operands() { BinaryExpressionTreeImpl e = (BinaryExpressionTreeImpl) expression("1 - 2 - 3"); BinaryExpressionTreeImpl leftOperand = (BinaryExpressionTreeImpl) e.leftOperand(); - assertThat(typeBinding(e)).isNotNull(); - assertThat(typeBinding(leftOperand)).isSameAs(typeBinding(e)); + assertThat(type(e)).isNotNull(); + assertThat(type(leftOperand)).isSameAs(type(e)); } /** - * @see org.eclipse.jdt.core.dom.SimpleName */ @Test void expression_simple_name() { @@ -173,12 +159,11 @@ void expression_simple_name() { MethodTreeImpl m = (MethodTreeImpl) c.members().get(1); ReturnStatementTree s = (ReturnStatementTree) m.block().body().get(0); IdentifierTreeImpl i = (IdentifierTreeImpl) s.expression(); - assertThat(binding(i)).isNotNull(); - assertThat(sema(cu).usages.get(binding(i))).containsOnly(i); + assertThat(symbol(i)).isNotNull(); + assertThat(SemanticTestSupport.usages(symbol(i))).containsOnly(i); } /** - * @see org.eclipse.jdt.core.dom.QualifiedName */ @Test void expression_qualified_name() { @@ -190,38 +175,37 @@ void expression_qualified_name() { MemberSelectExpressionTreeImpl javaLangSystemOut = (MemberSelectExpressionTreeImpl) s.expression(); MemberSelectExpressionTreeImpl javaLangSystem = (MemberSelectExpressionTreeImpl) javaLangSystemOut.expression(); - assertThat(typeBinding(javaLangSystem)).isNotNull(); - assertThat(sema(cu).type(typeBinding(javaLangSystem)).is("java.lang.System")) + assertThat(type(javaLangSystem)).isNotNull(); + assertThat((type(javaLangSystem)).is("java.lang.System")) .isEqualTo(javaLangSystem.symbolType().is("java.lang.System")) .isTrue(); MemberSelectExpressionTreeImpl javaLang = (MemberSelectExpressionTreeImpl) javaLangSystem.expression(); - assertThat(typeBinding(javaLang)).isNull(); + assertThat(type(javaLang)).isNull(); IdentifierTreeImpl java = (IdentifierTreeImpl) javaLang.expression(); - assertThat(typeBinding(java)).isNull(); - assertThat(binding(java)).isNotNull(); - assertThat(binding(java).getKind()).isSameAs(IBinding.PACKAGE); + assertThat(type(java)).isNull(); + assertThat(symbol(java)).isNotNull(); + assertThat(symbol(java).isPackageSymbol()).isTrue(); assertThat(java.symbol().isPackageSymbol()).isTrue(); IdentifierTreeImpl lang = (IdentifierTreeImpl) javaLang.identifier(); - assertThat(typeBinding(lang)).isNull(); - assertThat(binding(lang)).isNotNull(); - assertThat(binding(lang).getKind()).isSameAs(IBinding.PACKAGE); + assertThat(type(lang)).isNull(); + assertThat(symbol(lang)).isNotNull(); + assertThat(symbol(lang).isPackageSymbol()).isTrue(); assertThat(lang.symbol().isPackageSymbol()).isTrue(); IdentifierTreeImpl system = (IdentifierTreeImpl) javaLangSystem.identifier(); - assertThat(binding(system)) + assertThat(symbol(system)) .isNotNull() - .isEqualTo(typeBinding(system)); - assertThat(binding(system).getKind()).isSameAs(IBinding.TYPE); - assertThat(sema(cu).type(typeBinding(system)).is("java.lang.System")) + .isEqualTo(type(system).symbol()); + assertThat(symbol(system).isTypeSymbol()).isTrue(); + assertThat((type(system)).is("java.lang.System")) .isEqualTo(system.symbolType().is("java.lang.System")) .isTrue(); } /** - * @see org.eclipse.jdt.core.dom.ThisExpression */ @Test void expression_this() { @@ -230,18 +214,17 @@ void expression_this() { MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(m.block()).body().get(0); KeywordThis keywordThis = Objects.requireNonNull((KeywordThis) s.expression()); - assertThat(typeBinding(keywordThis)) + assertThat(type(keywordThis)) .isNotNull() - .isSameAs(typeBinding(Objects.requireNonNull((ClassTreeImpl) keywordThis.symbolType().symbol().declaration()))) - .isSameAs(typeBinding(c)); + .isSameAs(type(Objects.requireNonNull((ClassTreeImpl) keywordThis.symbolType().symbol().declaration()))) + .isSameAs(type(c)); assertThat(keywordThis.symbol()) - .isSameAs(sema(cu).typeSymbol(typeBinding(c)).thisSymbol); + .isSameAs(SemanticTestSupport.specialField(type(c), false)); assertThat(keywordThis.symbol().isVariableSymbol()) .isTrue(); } /** - * @see org.eclipse.jdt.core.dom.ThisExpression */ @Test void expression_this_qualified() { @@ -251,23 +234,22 @@ void expression_this_qualified() { MethodTreeImpl m = (MethodTreeImpl) c2.members().get(0); ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(m.block()).body().get(0); MemberSelectExpressionTreeImpl e = Objects.requireNonNull((MemberSelectExpressionTreeImpl) s.expression()); - assertThat(typeBinding(e)) + assertThat(type(e)) .isNotNull() - .isSameAs(typeBinding(Objects.requireNonNull((ClassTreeImpl) e.symbolType().symbol().declaration()))) - .isSameAs(typeBinding(c1)); + .isSameAs(type(Objects.requireNonNull((ClassTreeImpl) e.symbolType().symbol().declaration()))) + .isSameAs(type(c1)); KeywordThis keywordThis = (KeywordThis) e.identifier(); - assertThat(typeBinding(keywordThis)) + assertThat(type(keywordThis)) .isNotNull() - .isSameAs(typeBinding(Objects.requireNonNull((ClassTreeImpl) keywordThis.symbolType().symbol().declaration()))) - .isSameAs(typeBinding(c1)); + .isSameAs(type(Objects.requireNonNull((ClassTreeImpl) keywordThis.symbolType().symbol().declaration()))) + .isSameAs(type(c1)); assertThat(keywordThis.symbol()) - .isSameAs(sema(cu).typeSymbol(typeBinding(c1)).thisSymbol); + .isSameAs(SemanticTestSupport.specialField(type(c1), false)); assertThat(keywordThis.symbol().isVariableSymbol()) .isTrue(); } /** - * @see org.eclipse.jdt.core.dom.FieldAccess */ @Test void expression_field_access() { @@ -277,22 +259,21 @@ void expression_field_access() { MethodTreeImpl m = (MethodTreeImpl) c.members().get(1); ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(m.block()).body().get(0); MemberSelectExpressionTreeImpl expression = Objects.requireNonNull((MemberSelectExpressionTreeImpl) s.expression()); - assertThat(typeBinding(expression)) + assertThat(type(expression)) .isNotNull(); IdentifierTreeImpl identifier = (IdentifierTreeImpl) expression.identifier(); - assertThat(typeBinding(identifier)) - .isSameAs(typeBinding(expression)); - assertThat(binding(identifier)) + assertThat(type(identifier)) + .isSameAs(type(expression)); + assertThat(symbol(identifier)) .isNotNull() - .isSameAs(variableBinding(Objects.requireNonNull((VariableTreeImpl) identifier.symbol().declaration()))) - .isSameAs(variableBinding(field)); - assertThat(sema(cu).usages.get(binding(identifier))) + .isSameAs(symbol(Objects.requireNonNull((VariableTreeImpl) identifier.symbol().declaration()))) + .isSameAs(symbol(field)); + assertThat(SemanticTestSupport.usages(symbol(identifier))) .containsExactlyElementsOf(identifier.symbol().usages()) .containsOnly(identifier); } /** - * @see org.eclipse.jdt.core.dom.SuperFieldAccess */ @Test void expression_super_field_access() { @@ -308,20 +289,19 @@ void expression_super_field_access() { assertThat(keywordSuper.symbolType().symbol().declaration()) .isSameAs(superClass.symbol().declaration()); assertThat(keywordSuper.symbol()) - .isSameAs(sema(cu).typeSymbol(typeBinding(c)).superSymbol); + .isSameAs(SemanticTestSupport.specialField(type(c), true)); IdentifierTreeImpl identifier = (IdentifierTreeImpl) expression.identifier(); - assertThat(binding(identifier)) + assertThat(symbol(identifier)) .isNotNull() - .isSameAs(variableBinding(Objects.requireNonNull((VariableTreeImpl) identifier.symbol().declaration()))) - .isSameAs(variableBinding(superField)); - assertThat(sema(cu).usages.get(binding(identifier))) + .isSameAs(symbol(Objects.requireNonNull((VariableTreeImpl) identifier.symbol().declaration()))) + .isSameAs(symbol(superField)); + assertThat(SemanticTestSupport.usages(symbol(identifier))) .containsExactlyElementsOf(identifier.symbol().usages()) .containsOnly(identifier); } /** - * @see org.eclipse.jdt.core.dom.SuperFieldAccess */ @Test void expression_super_field_access_qualified() { @@ -335,29 +315,28 @@ void expression_super_field_access_qualified() { MemberSelectExpressionTreeImpl expression = Objects.requireNonNull((MemberSelectExpressionTreeImpl) s.expression()); MemberSelectExpressionTreeImpl qualifiedSuper = (MemberSelectExpressionTreeImpl) expression.expression(); - assertThat(typeBinding(qualifiedSuper)) - .isSameAs(typeBinding(Objects.requireNonNull((ClassTreeImpl) qualifiedSuper.symbolType().symbol().declaration()))) - .isSameAs(typeBinding(superClass)); + assertThat(type(qualifiedSuper)) + .isSameAs(type(Objects.requireNonNull((ClassTreeImpl) qualifiedSuper.symbolType().symbol().declaration()))) + .isSameAs(type(superClass)); KeywordSuper keywordSuper = (KeywordSuper) qualifiedSuper.identifier(); assertThat(keywordSuper.symbolType().symbol().declaration()) .isSameAs(Objects.requireNonNull((ClassTreeImpl) keywordSuper.symbolType().symbol().declaration())) .isSameAs(superClass); assertThat(keywordSuper.symbol()) - .isSameAs(sema(cu).typeSymbol(typeBinding(t)).superSymbol); + .isSameAs(SemanticTestSupport.specialField(type(t), true)); IdentifierTreeImpl identifier = (IdentifierTreeImpl) expression.identifier(); - assertThat(binding(identifier)) + assertThat(symbol(identifier)) .isNotNull() - .isSameAs(variableBinding(Objects.requireNonNull((VariableTreeImpl) identifier.symbol().declaration()))) - .isSameAs(variableBinding(superField)); - assertThat(sema(cu).usages.get(binding(identifier))) + .isSameAs(symbol(Objects.requireNonNull((VariableTreeImpl) identifier.symbol().declaration()))) + .isSameAs(symbol(superField)); + assertThat(SemanticTestSupport.usages(symbol(identifier))) .containsExactlyElementsOf(identifier.symbol().usages()) .containsOnly(identifier); } /** - * @see org.eclipse.jdt.core.dom.TypeLiteral */ @Test void expression_type_literal() { @@ -366,21 +345,20 @@ void expression_type_literal() { MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(m.block()).body().get(0); MemberSelectExpressionTreeImpl e = Objects.requireNonNull((MemberSelectExpressionTreeImpl) s.expression()); - assertThat(typeBinding(e)) + assertThat(type(e)) .isNotNull(); IdentifierTreeImpl i = (IdentifierTreeImpl) e.identifier(); - assertThat(typeBinding(i)) + assertThat(type(i)) .isNull(); assertThat(i.symbolType().isUnknown()) .isTrue(); - assertThat(binding(i)) + assertThat(symbol(i)) .isNull(); assertThat(i.symbol().isUnknown()) .isTrue(); } /** - * @see org.eclipse.jdt.core.dom.ClassInstanceCreation */ @Test void expression_class_instance_creation() { @@ -390,22 +368,21 @@ void expression_class_instance_creation() { MethodTreeImpl constructor = (MethodTreeImpl) c.members().get(1); ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(m.block()).body().get(0); NewClassTreeImpl e = Objects.requireNonNull((NewClassTreeImpl) s.expression()); - assertThat(typeBinding(e)) + assertThat(type(e)) .isNotNull() - .isSameAs(typeBinding(Objects.requireNonNull((ClassTreeImpl) e.symbolType().symbol().declaration()))) - .isSameAs(typeBinding(c)); + .isSameAs(type(Objects.requireNonNull((ClassTreeImpl) e.symbolType().symbol().declaration()))) + .isSameAs(type(c)); IdentifierTreeImpl i = (IdentifierTreeImpl) e.getConstructorIdentifier(); - assertThat(binding(i)) + assertThat(symbol(i)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) i.symbol().declaration()))) - .isSameAs(methodBinding(constructor)); - assertThat(sema(cu).usages.get(methodBinding(constructor))) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) i.symbol().declaration()))) + .isSameAs(method(constructor)); + assertThat(SemanticTestSupport.usages(method(constructor))) .containsExactlyElementsOf(constructor.symbol().usages()) .containsOnly(i); } /** - * @see org.eclipse.jdt.core.dom.ClassInstanceCreation */ @Test void expression_anonymous_class_instance_creation() { @@ -416,23 +393,22 @@ void expression_anonymous_class_instance_creation() { ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(m.block()).body().get(0); NewClassTreeImpl e = (NewClassTreeImpl) s.expression(); ClassTreeImpl b = (ClassTreeImpl) e.classBody(); - assertThat(typeBinding(b)).isNotNull(); - assertThat(sema(cu).declarations.get(typeBinding(b))) + assertThat(type(b)).isNotNull(); + assertThat(SemanticTestSupport.declaration(type(b))) .isSameAs(b.symbol().declaration()) .isSameAs(b); IdentifierTreeImpl identifier = (IdentifierTreeImpl) e.getConstructorIdentifier(); - assertThat(binding(identifier)) + assertThat(symbol(identifier)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) identifier.symbol().declaration()))) - .isSameAs(methodBinding(constructor)); - assertThat(sema(cu).usages.get(methodBinding(constructor))) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) identifier.symbol().declaration()))) + .isSameAs(method(constructor)); + assertThat(SemanticTestSupport.usages(method(constructor))) .containsExactlyElementsOf(constructor.symbol().usages()) .containsOnly(identifier); } /** - * @see org.eclipse.jdt.core.dom.CreationReference */ @Test void expression_creation_reference() { @@ -443,17 +419,16 @@ void expression_creation_reference() { ReturnStatementTreeImpl s = (ReturnStatementTreeImpl) m.block().body().get(0); MethodReferenceTreeImpl creationReference = (MethodReferenceTreeImpl) s.expression(); IdentifierTreeImpl keywordNew = (IdentifierTreeImpl) creationReference.method(); - assertThat(binding(keywordNew)) + assertThat(symbol(keywordNew)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) creationReference.method().symbol().declaration()))) - .isSameAs(methodBinding(constructor)); - assertThat(sema(cu).usages.get(methodBinding(constructor))) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) creationReference.method().symbol().declaration()))) + .isSameAs(method(constructor)); + assertThat(SemanticTestSupport.usages(method(constructor))) .containsExactlyElementsOf(constructor.symbol().usages()) .containsOnly(keywordNew); } /** - * @see org.eclipse.jdt.core.dom.MethodReference */ @Test void expression_method_reference() { @@ -463,17 +438,16 @@ void expression_method_reference() { ReturnStatementTreeImpl s = (ReturnStatementTreeImpl) method.block().body().get(0); MethodReferenceTreeImpl creationReference = (MethodReferenceTreeImpl) s.expression(); IdentifierTreeImpl identifier = (IdentifierTreeImpl) creationReference.method(); - assertThat(binding(identifier)) + assertThat(symbol(identifier)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) creationReference.method().symbol().declaration()))) - .isSameAs(methodBinding(method)); - assertThat(sema(cu).usages.get(methodBinding(method))) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) creationReference.method().symbol().declaration()))) + .isSameAs(method(method)); + assertThat(SemanticTestSupport.usages(method(method))) .containsExactlyElementsOf(method.symbol().usages()) .containsOnly(identifier); } /** - * @see org.eclipse.jdt.core.dom.TypeMethodReference */ @Test void expression_type_method_reference() { @@ -483,17 +457,16 @@ void expression_type_method_reference() { ReturnStatementTreeImpl s = (ReturnStatementTreeImpl) method.block().body().get(0); MethodReferenceTreeImpl creationReference = (MethodReferenceTreeImpl) s.expression(); IdentifierTreeImpl identifier = (IdentifierTreeImpl) creationReference.method(); - assertThat(binding(identifier)) + assertThat(symbol(identifier)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) creationReference.method().symbol().declaration()))) - .isSameAs(methodBinding(method)); - assertThat(sema(cu).usages.get(methodBinding(method))) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) creationReference.method().symbol().declaration()))) + .isSameAs(method(method)); + assertThat(SemanticTestSupport.usages(method(method))) .containsExactlyElementsOf(method.symbol().usages()) .containsOnly(identifier); } /** - * @see org.eclipse.jdt.core.dom.SuperMethodReference */ @Test void expression_super_method_reference() { @@ -516,20 +489,19 @@ class S { assertThat(keywordSuper.symbolType().symbol().declaration()) .isSameAs(superClass.symbol().declaration()); assertThat(keywordSuper.symbol()) - .isSameAs(sema(cu).typeSymbol(typeBinding(c)).superSymbol); + .isSameAs(SemanticTestSupport.specialField(type(c), true)); IdentifierTreeImpl identifier = (IdentifierTreeImpl) creationReference.method(); - assertThat(binding(identifier)) + assertThat(symbol(identifier)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) creationReference.method().symbol().declaration()))) - .isSameAs(methodBinding(superClassMethod)); - assertThat(sema(cu).usages.get(methodBinding(superClassMethod))) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) creationReference.method().symbol().declaration()))) + .isSameAs(method(superClassMethod)); + assertThat(SemanticTestSupport.usages(method(superClassMethod))) .containsExactlyElementsOf(superClassMethod.symbol().usages()) .containsOnly(identifier); } /** - * @see org.eclipse.jdt.core.dom.SuperMethodReference */ @Test void expression_super_method_reference_qualified() { @@ -554,21 +526,19 @@ class S { assertThat(keywordSuper.symbolType().symbol().declaration()) .isSameAs(superClass.symbol().declaration()); assertThat(keywordSuper.symbol()) - .isSameAs(sema(cu).typeSymbol(typeBinding(c)).superSymbol); + .isSameAs(SemanticTestSupport.specialField(type(c), true)); IdentifierTreeImpl identifier = (IdentifierTreeImpl) creationReference.method(); - assertThat(binding(identifier)) + assertThat(symbol(identifier)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) creationReference.method().symbol().declaration()))) - .isSameAs(methodBinding(superClassMethod)); - assertThat(sema(cu).usages.get(methodBinding(superClassMethod))) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) creationReference.method().symbol().declaration()))) + .isSameAs(method(superClassMethod)); + assertThat(SemanticTestSupport.usages(method(superClassMethod))) .containsExactlyElementsOf(superClassMethod.symbol().usages()) .containsOnly(identifier); } /** - * @see org.eclipse.jdt.core.dom.SwitchExpression - * @see org.eclipse.jdt.core.dom.YieldStatement */ @Test void expression_switch() { @@ -630,7 +600,6 @@ void switch_expression_of_enum_without_default_clause() { * (Second Preview in Java 15) https://openjdk.java.net/jeps/375 * (Final in Java 16) https://openjdk.java.net/jeps/394 * - * @see org.eclipse.jdt.core.dom.InstanceofExpression */ @Test void expression_pattern_instanceof() { @@ -643,12 +612,11 @@ void expression_pattern_instanceof() { .is("java.lang.String") .is(i.symbolType()); - assertThat(binding(i)).isNotNull(); + assertThat(symbol(i)).isNotNull(); assertThat(i.symbol().declaration()).isEqualTo(v); } /** - * @see org.eclipse.jdt.core.dom.MethodInvocation */ @Test void expression_method_invocation() { @@ -658,21 +626,20 @@ void expression_method_invocation() { ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(method.block()).body().get(0); MethodInvocationTreeImpl methodInvocation = (MethodInvocationTreeImpl) s.expression(); - assertThat(methodBinding(methodInvocation)) + assertThat(method(methodInvocation)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) methodInvocation.methodSymbol().declaration()))) - .isSameAs(methodBinding(method)); + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) methodInvocation.methodSymbol().declaration()))) + .isSameAs(method(method)); IdentifierTreeImpl i = (IdentifierTreeImpl) methodInvocation.methodSelect(); - assertThat(binding(i)) - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) i.symbol().declaration()))) - .isSameAs(methodBinding(methodInvocation)); - assertThat(sema(cu).usages.get(binding(i))) + assertThat(symbol(i)) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) i.symbol().declaration()))) + .isSameAs(method(methodInvocation)); + assertThat(SemanticTestSupport.usages(symbol(i))) .containsExactlyElementsOf(methodInvocation.methodSymbol().usages()) .containsOnly(i); } /** - * @see org.eclipse.jdt.core.dom.MethodInvocation */ @Test void expression_method_invocation_recovery() { @@ -681,17 +648,16 @@ void expression_method_invocation_recovery() { MethodTreeImpl method = (MethodTreeImpl) c.members().get(0); ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(method.block()).body().get(0); MethodInvocationTreeImpl methodInvocation = Objects.requireNonNull((MethodInvocationTreeImpl) s.expression()); - assertThat(methodBinding(methodInvocation)) + assertThat(method(methodInvocation)) .isNull(); IdentifierTreeImpl i = (IdentifierTreeImpl) methodInvocation.methodSelect(); - assertThat(binding(i)) + assertThat(symbol(i)) .isNull(); - assertThat(sema(cu).usages.get(Objects.requireNonNull(methodBinding(method)))) + assertThat(SemanticTestSupport.usages(Objects.requireNonNull(method(method)))) .isNull(); } /** - * @see org.eclipse.jdt.core.dom.SuperMethodInvocation */ @Test void expression_super_method_invocation() { @@ -703,29 +669,28 @@ void expression_super_method_invocation() { ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(m.block()).body().get(0); MethodInvocationTreeImpl superMethodInvocation = (MethodInvocationTreeImpl) Objects.requireNonNull(s.expression()); - assertThat(methodBinding(superMethodInvocation)) + assertThat(method(superMethodInvocation)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) superMethodInvocation.methodSymbol().declaration()))) - .isSameAs(methodBinding(superClassMethod)); + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) superMethodInvocation.methodSymbol().declaration()))) + .isSameAs(method(superClassMethod)); MemberSelectExpressionTreeImpl e2 = (MemberSelectExpressionTreeImpl) superMethodInvocation.methodSelect(); KeywordSuper keywordSuper = (KeywordSuper) e2.expression(); assertThat(keywordSuper.symbolType().symbol().declaration()) .isSameAs(superClass.symbol().declaration()); assertThat(keywordSuper.symbol()) - .isSameAs(sema(cu).typeSymbol(typeBinding(c)).superSymbol); + .isSameAs(SemanticTestSupport.specialField(type(c), true)); IdentifierTreeImpl i = (IdentifierTreeImpl) e2.identifier(); - assertThat(binding(i)) - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) i.symbol().declaration()))) - .isSameAs(methodBinding(superMethodInvocation)); - assertThat(sema(cu).usages.get(binding(i))) + assertThat(symbol(i)) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) i.symbol().declaration()))) + .isSameAs(method(superMethodInvocation)); + assertThat(SemanticTestSupport.usages(symbol(i))) .containsExactlyElementsOf(superMethodInvocation.methodSymbol().usages()) .containsOnly(i); } /** - * @see org.eclipse.jdt.core.dom.SuperMethodInvocation */ @Test void expression_super_method_invocation_recovery() { @@ -737,18 +702,17 @@ void expression_super_method_invocation_recovery() { ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(m.block()).body().get(0); MethodInvocationTreeImpl superMethodInvocation = (MethodInvocationTreeImpl) Objects.requireNonNull(s.expression()); - assertThat(methodBinding(superMethodInvocation)) + assertThat(method(superMethodInvocation)) .isNull(); MemberSelectExpressionTreeImpl e = (MemberSelectExpressionTreeImpl) superMethodInvocation.methodSelect(); IdentifierTreeImpl i = (IdentifierTreeImpl) e.identifier(); - assertThat(binding(i)) + assertThat(symbol(i)) .isNull(); - assertThat(sema(cu).usages.get(Objects.requireNonNull(methodBinding(superClassMethod)))) + assertThat(SemanticTestSupport.usages(Objects.requireNonNull(method(superClassMethod)))) .isNull(); } /** - * @see org.eclipse.jdt.core.dom.SuperMethodInvocation */ @Test void expression_super_method_invocation_qualified() { @@ -761,34 +725,34 @@ void expression_super_method_invocation_qualified() { ReturnStatementTree s = (ReturnStatementTree) Objects.requireNonNull(m.block()).body().get(0); MethodInvocationTreeImpl superMethodInvocation = (MethodInvocationTreeImpl) Objects.requireNonNull(s.expression()); - assertThat(methodBinding(superMethodInvocation)) + assertThat(method(superMethodInvocation)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) superMethodInvocation.methodSymbol().declaration()))) - .isSameAs(methodBinding(superClassMethod)); + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) superMethodInvocation.methodSymbol().declaration()))) + .isSameAs(method(superClassMethod)); MemberSelectExpressionTreeImpl qualifiedMethodName = (MemberSelectExpressionTreeImpl) superMethodInvocation.methodSelect(); assertThat(qualifiedMethodName.symbolType().isUnknown()) .isTrue(); - assertThat(typeBinding(qualifiedMethodName)) + assertThat(type(qualifiedMethodName)) .isNull(); MemberSelectExpressionTreeImpl qualifiedSuper = (MemberSelectExpressionTreeImpl) qualifiedMethodName.expression(); - assertThat(typeBinding(qualifiedSuper)) + assertThat(type(qualifiedSuper)) .isNotNull() - .isSameAs(typeBinding(Objects.requireNonNull((ClassTreeImpl) qualifiedSuper.symbolType().symbol().declaration()))) - .isSameAs(typeBinding(superClass)); + .isSameAs(type(Objects.requireNonNull((ClassTreeImpl) qualifiedSuper.symbolType().symbol().declaration()))) + .isSameAs(type(superClass)); KeywordSuper keywordSuper = (KeywordSuper) qualifiedSuper.identifier(); assertThat(keywordSuper.symbolType().symbol().declaration()) .isSameAs(superClass); assertThat(keywordSuper.symbol()) - .isSameAs(sema(cu).typeSymbol(typeBinding(t)).superSymbol); + .isSameAs(SemanticTestSupport.specialField(type(t), true)); IdentifierTreeImpl identifier = (IdentifierTreeImpl) qualifiedMethodName.identifier(); - assertThat(binding(identifier)) - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) identifier.symbol().declaration()))) - .isSameAs(methodBinding(superMethodInvocation)); - assertThat(sema(cu).usages.get(binding(identifier))) + assertThat(symbol(identifier)) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) identifier.symbol().declaration()))) + .isSameAs(method(superMethodInvocation)); + assertThat(SemanticTestSupport.usages(symbol(identifier))) .containsExactlyElementsOf(superMethodInvocation.methodSymbol().usages()) .containsOnly(identifier); } @@ -812,7 +776,7 @@ default void forEach(java.util.function.Consumer action) { MemberSelectExpressionTreeImpl iterableSuper = (MemberSelectExpressionTreeImpl) iterableSuperForeach.expression(); IdentifierTreeImpl superKeyword = (IdentifierTreeImpl) iterableSuper.identifier(); - assertThat(typeBinding(superKeyword)).isNotNull(); + assertThat(type(superKeyword)).isNotNull(); assertThat(superKeyword.symbolType().fullyQualifiedName()).isEqualTo("java.lang.Iterable"); } @@ -833,10 +797,10 @@ class A { var lambda = (LambdaExpressionTree) f.initializer(); var p = (VariableTreeImpl) lambda.parameters().get(0); - Symbol newSymbol = sema(cu).variableSymbol(variableBinding(p)); + Symbol newSymbol = (symbol(p)); assertThat(newSymbol.declaration().firstToken().range().start().line()).isEqualTo(3); Symbol newOwner = newSymbol.owner(); - assertTrue(newOwner instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()); + assertTrue(SemanticTestSupport.isLambda(newOwner)); } /** @@ -864,9 +828,9 @@ void foo() { VariableTreeImpl p = (VariableTreeImpl) lambda.parameters().get(0); // owner of lambda parameter is the field or variable to which it is assigned - Symbol newSymbol = sema(cu).variableSymbol(variableBinding(p)); + Symbol newSymbol = (symbol(p)); Symbol newOwner = newSymbol.owner(); - assertTrue(newOwner instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()); + assertTrue(SemanticTestSupport.isLambda(newOwner)); } @Test @@ -893,12 +857,11 @@ void m() { ReturnStatementTreeImpl r = (ReturnStatementTreeImpl) body.body().get(0); LambdaExpressionTreeImpl l2 = (LambdaExpressionTreeImpl) r.expression(); - assertThat(typeBinding(l2)).isNotNull(); - assertThat(sema(cu).type(typeBinding(l2)).is("java.util.function.Supplier")).isTrue(); + assertThat(type(l2)).isNotNull(); + assertThat((type(l2)).is("java.util.function.Supplier")).isTrue(); } /** - * @see org.eclipse.jdt.core.dom.ConditionalExpression */ @Test void conditional_expression() { @@ -919,16 +882,16 @@ void foo(Class[] arr1, Class[] arr2, boolean IdentifierTreeImpl c1 = (IdentifierTreeImpl) cond.trueExpression(); IdentifierTreeImpl c2 = (IdentifierTreeImpl) cond.falseExpression(); - assertThat(typeBinding(cond)).isNotNull(); - JType tcond = sema(cu).type(typeBinding(cond)); + assertThat(type(cond)).isNotNull(); + Type tcond = (type(cond)); assertThat(tcond.is("java.lang.Class[]")).isTrue(); - assertThat(typeBinding(c1)).isNotNull(); - JType tc1 = sema(cu).type(typeBinding(c1)); + assertThat(type(c1)).isNotNull(); + Type tc1 = (type(c1)); assertThat(tc1.is("java.lang.Class[]")).isTrue(); - assertThat(typeBinding(c2)).isNotNull(); - JType tc2 = sema(cu).type(typeBinding(c2)); + assertThat(type(c2)).isNotNull(); + Type tc2 = (type(c2)); assertThat(tc2.is("java.lang.Class[]")).isTrue(); assertThat(tc2) @@ -937,7 +900,6 @@ void foo(Class[] arr1, Class[] arr2, boolean } /** - * @see org.eclipse.jdt.core.dom.ConstructorInvocation */ @Test void statement_constructor_invocation() { @@ -948,25 +910,24 @@ void statement_constructor_invocation() { ExpressionStatementTree s = (ExpressionStatementTree) m.block().body().get(0); MethodInvocationTreeImpl constructorInvocation = (MethodInvocationTreeImpl) s.expression(); - assertThat(methodBinding(constructorInvocation)) + assertThat(method(constructorInvocation)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) constructorInvocation.methodSymbol().declaration()))) - .isSameAs(methodBinding(constructor2)); - assertThat(typeBinding(constructorInvocation)) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) constructorInvocation.methodSymbol().declaration()))) + .isSameAs(method(constructor2)); + assertThat(type(constructorInvocation)) .isNotNull() - .isSameAs(typeBinding(Objects.requireNonNull(((ClassTreeImpl) constructorInvocation.symbolType().symbol().declaration())))) - .isSameAs(typeBinding(c)); + .isSameAs(type(Objects.requireNonNull(((ClassTreeImpl) constructorInvocation.symbolType().symbol().declaration())))) + .isSameAs(type(c)); IdentifierTreeImpl i = (IdentifierTreeImpl) constructorInvocation.methodSelect(); - assertThat(binding(i)) - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) i.symbol().declaration()))) - .isSameAs(methodBinding(constructorInvocation)); - assertThat(sema(cu).usages.get(binding(i))) + assertThat(symbol(i)) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) i.symbol().declaration()))) + .isSameAs(method(constructorInvocation)); + assertThat(SemanticTestSupport.usages(symbol(i))) .containsExactlyElementsOf(constructorInvocation.methodSymbol().usages()) .containsOnly(i); } /** - * @see org.eclipse.jdt.core.dom.ConstructorInvocation */ @Test void statement_constructor_invocation_recovery() { @@ -976,20 +937,19 @@ void statement_constructor_invocation_recovery() { ExpressionStatementTree s = (ExpressionStatementTree) Objects.requireNonNull(m.block()).body().get(0); MethodInvocationTreeImpl constructorInvocation = (MethodInvocationTreeImpl) s.expression(); - assertThat(methodBinding(constructorInvocation)) + assertThat(method(constructorInvocation)) .isNull(); - assertThat(typeBinding(constructorInvocation)) + assertThat(type(constructorInvocation)) .isNotNull() - .isSameAs(typeBinding(c)); + .isSameAs(type(c)); IdentifierTreeImpl i = (IdentifierTreeImpl) constructorInvocation.methodSelect(); - assertThat(binding(i)) + assertThat(symbol(i)) .isNull(); - assertThat(sema(cu).usages.get(Objects.requireNonNull(methodBinding(m)))) + assertThat(SemanticTestSupport.usages(Objects.requireNonNull(method(m)))) .isNull(); } /** - * @see org.eclipse.jdt.core.dom.SuperConstructorInvocation */ @Test void statement_super_constructor_invocation() { @@ -1001,25 +961,24 @@ void statement_super_constructor_invocation() { ExpressionStatementTree s = (ExpressionStatementTree) m.block().body().get(0); MethodInvocationTreeImpl superConstructorInvocation = (MethodInvocationTreeImpl) s.expression(); - assertThat(methodBinding(superConstructorInvocation)) + assertThat(method(superConstructorInvocation)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) superConstructorInvocation.methodSymbol().declaration()))) - .isSameAs(methodBinding(superClassConstructor)); - assertThat(typeBinding(superConstructorInvocation)) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) superConstructorInvocation.methodSymbol().declaration()))) + .isSameAs(method(superClassConstructor)); + assertThat(type(superConstructorInvocation)) .isNotNull() - .isSameAs(typeBinding(Objects.requireNonNull(((ClassTreeImpl) superConstructorInvocation.symbolType().symbol().declaration())))) - .isSameAs(typeBinding(superClass)); + .isSameAs(type(Objects.requireNonNull(((ClassTreeImpl) superConstructorInvocation.symbolType().symbol().declaration())))) + .isSameAs(type(superClass)); IdentifierTreeImpl i = (IdentifierTreeImpl) superConstructorInvocation.methodSelect(); - assertThat(binding(i)) - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) i.symbol().declaration()))) - .isSameAs(methodBinding(superConstructorInvocation)); - assertThat(sema(cu).usages.get(binding(i))) + assertThat(symbol(i)) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) i.symbol().declaration()))) + .isSameAs(method(superConstructorInvocation)); + assertThat(SemanticTestSupport.usages(symbol(i))) .containsExactlyElementsOf(superClassConstructor.symbol().usages()) .containsOnly(i); } /** - * @see org.eclipse.jdt.core.dom.SuperConstructorInvocation */ @Test void statement_super_constructor_invocation_recovery() { @@ -1031,15 +990,15 @@ void statement_super_constructor_invocation_recovery() { ExpressionStatementTree s = (ExpressionStatementTree) Objects.requireNonNull(m.block()).body().get(0); MethodInvocationTreeImpl superConstructorInvocation = (MethodInvocationTreeImpl) s.expression(); - assertThat(methodBinding(superConstructorInvocation)) + assertThat(method(superConstructorInvocation)) .isNull(); - assertThat(typeBinding(superConstructorInvocation)) + assertThat(type(superConstructorInvocation)) .isNotNull() - .isSameAs(typeBinding(superClass)); + .isSameAs(type(superClass)); IdentifierTreeImpl i = (IdentifierTreeImpl) superConstructorInvocation.methodSelect(); - assertThat(binding(i)) + assertThat(symbol(i)) .isNull(); - assertThat(sema(cu).usages.get(Objects.requireNonNull(methodBinding(superClassConstructor)))) + assertThat(SemanticTestSupport.usages(Objects.requireNonNull(method(superClassConstructor)))) .isNull(); } @@ -1049,8 +1008,8 @@ void statement_variable_declaration() { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); VariableTreeImpl s = (VariableTreeImpl) m.block().body().get(0); - assertThat(variableBinding(s)).isNotNull(); - assertThat(sema(cu).declarations.get(variableBinding(s))).isSameAs(s); + assertThat(symbol(s)).isNotNull(); + assertThat(SemanticTestSupport.declaration(symbol(s))).isSameAs(s); assertThat(s.symbol().isUnknown()).isFalse(); assertThat(s.symbol().name()).isEqualTo("v"); @@ -1068,12 +1027,11 @@ void statement_for() { MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); ForStatementTreeImpl s = (ForStatementTreeImpl) m.block().body().get(0); VariableTreeImpl v = (VariableTreeImpl) s.initializer().get(0); - assertThat(variableBinding(v)).isNotNull(); - assertThat(sema(cu).declarations.get(variableBinding(v))).isSameAs(v); + assertThat(symbol(v)).isNotNull(); + assertThat(SemanticTestSupport.declaration(symbol(v))).isSameAs(v); } /** - * @see org.eclipse.jdt.core.dom.ImportDeclaration */ @Test void declaration_import() { @@ -1081,11 +1039,11 @@ void declaration_import() { JavaTree.ImportTreeImpl i = (JavaTree.ImportTreeImpl) cu.imports().get(0); MemberSelectExpressionTreeImpl qualifiedName = (MemberSelectExpressionTreeImpl) i.qualifiedIdentifier(); IdentifierTreeImpl identifier = (IdentifierTreeImpl) qualifiedName.identifier(); - assertThat(binding(identifier)) + assertThat(symbol(identifier)) .isNull(); - assertThat(binding(i)) + assertThat(symbol(i)) .isNotNull(); - assertThat(sema(cu).typeSymbol((ITypeBinding) binding(i)).usages()) + assertThat((symbol(i).type()).symbol().usages()) .isEmpty(); } @@ -1093,11 +1051,11 @@ void declaration_import() { void declaration_type() { JavaTree.CompilationUnitTreeImpl cu = test("class C { }"); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); - assertThat(typeBinding(c)).isNotNull(); - assertThat(sema(cu).declarations.get(typeBinding(c))).isSameAs(c); + assertThat(type(c)).isNotNull(); + assertThat(SemanticTestSupport.declaration(type(c))).isSameAs(c); TypeParameterTreeImpl typeParameter = (TypeParameterTreeImpl) c.typeParameters().get(0); - assertThat(typeBinding(typeParameter)) + assertThat(type(typeParameter)) .isNotNull(); assertThat(typeParameter.symbol().isUnknown()).isFalse(); assertThat(typeParameter.symbol().name()).isEqualTo("T"); @@ -1114,7 +1072,6 @@ void declaration_type() { * (Second Preview in Java 15) https://openjdk.java.net/jeps/384 * (Final in Java 16) https://openjdk.java.net/jeps/395 * - * @see org.eclipse.jdt.core.dom.RecordDeclaration */ @Test void declaration_record() { @@ -1141,7 +1098,6 @@ void declaration_record() { * (Second Preview in Java 16) https://openjdk.java.net/jeps/397 * (Final in Java 17) https://openjdk.java.net/jeps/409 * - * @see org.eclipse.jdt.core.dom.TypeDeclaration */ @Test void declaration_sealed_class() { @@ -1173,8 +1129,8 @@ void declaration_sealed_class() { } /** - * {@link org.eclipse.jdt.core.dom.ITypeBinding#getTypeDeclaration()} should be used - * for {@link JSymbol#usages()} and {@link JSymbol#declaration()} + * The canonical type declaration should be used + * for {@link Symbol#usages()} and {@link Symbol#declaration()} */ @Test void declaration_type_parameterized() { @@ -1183,20 +1139,19 @@ void declaration_type_parameterized() { AbstractTypedTree fieldType = (AbstractTypedTree) ((VariableTreeImpl) c.members().get(0)).type(); IdentifierTreeImpl i = (IdentifierTreeImpl) ((ParameterizedTypeTree) fieldType).type(); - assertThat(sema(cu).usages.get(typeBinding(c))) + assertThat(SemanticTestSupport.usages(type(c))) .containsOnly(i); - assertThat(typeBinding(fieldType)) + assertThat(type(fieldType)) .isNotNull(); - assertThat(sema(cu).typeSymbol(typeBinding(fieldType)).declaration()) + assertThat((type(fieldType)).symbol().declaration()) .isSameAs(fieldType.symbolType().symbol().declaration()) .isSameAs(c); - assertThat(sema(cu).typeSymbol(typeBinding(fieldType)).usages()) + assertThat((type(fieldType)).symbol().usages()) .containsExactlyElementsOf(fieldType.symbolType().symbol().usages()) .containsOnly(i); } /** - * @see org.eclipse.jdt.core.dom.EnumConstantDeclaration */ @Test void declaration_enum_constant() { @@ -1204,22 +1159,21 @@ void declaration_enum_constant() { ClassTree e = (ClassTree) cu.types().get(0); VariableTreeImpl c = (VariableTreeImpl) e.members().get(0); MethodTreeImpl constructor = (MethodTreeImpl) e.members().get(1); - assertThat(variableBinding(c)).isNotNull(); - assertThat(sema(cu).declarations.get(variableBinding(c))) + assertThat(symbol(c)).isNotNull(); + assertThat(SemanticTestSupport.declaration(symbol(c))) .isSameAs(c.symbol().declaration()) .isSameAs(c); NewClassTreeImpl initializer = Objects.requireNonNull((NewClassTreeImpl) c.initializer()); IdentifierTreeImpl i = (IdentifierTreeImpl) initializer.getConstructorIdentifier(); - assertThat(binding(i)) + assertThat(symbol(i)) .isNotNull() - .isSameAs(methodBinding(((MethodTreeImpl) i.symbol().declaration()))) - .isSameAs(methodBinding(constructor)); - assertThat(sema(cu).usages.get(methodBinding(constructor))) + .isSameAs(method(((MethodTreeImpl) i.symbol().declaration()))) + .isSameAs(method(constructor)); + assertThat(SemanticTestSupport.usages(method(constructor))) .containsOnly(i); } /** - * @see org.eclipse.jdt.core.dom.EnumConstantDeclaration */ @Test void declaration_enum_constant_recovered_constructor() { @@ -1228,12 +1182,11 @@ void declaration_enum_constant_recovered_constructor() { VariableTreeImpl c = (VariableTreeImpl) e.members().get(0); NewClassTreeImpl initializer = Objects.requireNonNull((NewClassTreeImpl) c.initializer()); IdentifierTreeImpl i = (IdentifierTreeImpl) initializer.getConstructorIdentifier(); - assertThat(binding(i)).isNull(); + assertThat(symbol(i)).isNull(); assertThat(i.symbol().isUnknown()).isTrue(); } /** - * @see org.eclipse.jdt.core.dom.EnumConstantDeclaration */ @Test void declaration_enum_constant_anonymous() { @@ -1241,24 +1194,24 @@ void declaration_enum_constant_anonymous() { ClassTree e = (ClassTree) cu.types().get(0); MethodTreeImpl constructor = (MethodTreeImpl) e.members().get(1); VariableTreeImpl c = (VariableTreeImpl) e.members().get(0); - assertThat(variableBinding(c)).isNotNull(); - assertThat(sema(cu).declarations.get(variableBinding(c))) + assertThat(symbol(c)).isNotNull(); + assertThat(SemanticTestSupport.declaration(symbol(c))) .isSameAs(c.symbol().declaration()) .isSameAs(c); NewClassTreeImpl initializer = (NewClassTreeImpl) c.initializer(); ClassTreeImpl enumConstantBody = (ClassTreeImpl) initializer.classBody(); - assertThat(typeBinding(enumConstantBody)).isNotNull(); - assertThat(sema(cu).declarations.get(typeBinding(enumConstantBody))) + assertThat(type(enumConstantBody)).isNotNull(); + assertThat(SemanticTestSupport.declaration(type(enumConstantBody))) .isSameAs(enumConstantBody.symbol().declaration()) .isSameAs(enumConstantBody); IdentifierTreeImpl identifier = (IdentifierTreeImpl) initializer.getConstructorIdentifier(); - assertThat(binding(identifier)) + assertThat(symbol(identifier)) .isNotNull() - .isSameAs(methodBinding(Objects.requireNonNull((MethodTreeImpl) identifier.symbol().declaration()))) - .isSameAs(methodBinding(constructor)); - assertThat(sema(cu).usages.get(methodBinding(constructor))) + .isSameAs(method(Objects.requireNonNull((MethodTreeImpl) identifier.symbol().declaration()))) + .isSameAs(method(constructor)); + assertThat(SemanticTestSupport.usages(method(constructor))) .containsExactlyElementsOf(constructor.symbol().usages()) .containsOnly(identifier); } @@ -1268,13 +1221,13 @@ void declaration_method() { JavaTree.CompilationUnitTreeImpl cu = test("class C { void m() {} }"); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - assertThat(methodBinding(m)).isNotNull(); - assertThat(sema(cu).declarations.get(methodBinding(m))).isSameAs(m); + assertThat(method(m)).isNotNull(); + assertThat(SemanticTestSupport.declaration(method(m))).isSameAs(m); } /** - * {@link org.eclipse.jdt.core.dom.IMethodBinding#getMethodDeclaration()} should be used - * for {@link JSymbol#usages()} and {@link JSymbol#declaration()} + * The canonical method declaration should be used + * for {@link Symbol#usages()} and {@link Symbol#declaration()} */ @Test void declaration_method_parameterized() { @@ -1285,14 +1238,14 @@ void declaration_method_parameterized() { MethodInvocationTreeImpl methodInvocation = (MethodInvocationTreeImpl) s.expression(); IdentifierTreeImpl i = (IdentifierTreeImpl) methodInvocation.methodSelect(); - assertThat(sema(cu).usages.get(methodBinding(m))) + assertThat(SemanticTestSupport.usages(method(m))) .containsOnly(i); - assertThat(methodBinding(methodInvocation)) + assertThat(method(methodInvocation)) .isNotNull(); - assertThat(sema(cu).methodSymbol(methodBinding(methodInvocation)).declaration()) + assertThat((method(methodInvocation)).declaration()) .isSameAs(methodInvocation.methodSymbol().declaration()) .isSameAs(m); - assertThat(sema(cu).methodSymbol(methodBinding(methodInvocation)).usages()) + assertThat((method(methodInvocation)).usages()) .containsExactlyElementsOf(methodInvocation.methodSymbol().usages()) .containsOnly(i); } @@ -1310,7 +1263,7 @@ private java.util.Collection> samples() { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - assertThat(methodBinding(m)).isNull(); + assertThat(method(m)).isNull(); MethodSymbol recovered = m.symbol(); assertThat(recovered.isUnknown()).isTrue(); @@ -1380,8 +1333,8 @@ void declaration_parameter() { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); VariableTreeImpl p = (VariableTreeImpl) m.parameters().get(0); - assertThat(variableBinding(p)).isNotNull(); - assertThat(sema(cu).declarations.get(variableBinding(p))).isSameAs(p); + assertThat(symbol(p)).isNotNull(); + assertThat(SemanticTestSupport.declaration(symbol(p))).isSameAs(p); } @Test @@ -1389,8 +1342,8 @@ void declaration_field() { JavaTree.CompilationUnitTreeImpl cu = test("class C { int f; }"); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); VariableTreeImpl f = (VariableTreeImpl) c.members().get(0); - assertThat(variableBinding(f)).isNotNull(); - assertThat(sema(cu).declarations.get(variableBinding(f))).isSameAs(f); + assertThat(symbol(f)).isNotNull(); + assertThat(SemanticTestSupport.declaration(symbol(f))).isSameAs(f); } @Test @@ -1402,10 +1355,10 @@ void declaration_lambda_parameter() { MethodInvocationTreeImpl i = (MethodInvocationTreeImpl) s.expression(); LambdaExpressionTree e = (LambdaExpressionTree) i.arguments().get(0); VariableTreeImpl v = (VariableTreeImpl) e.parameters().get(0); - assertThat(variableBinding(v)).isNotNull(); + assertThat(symbol(v)).isNotNull(); AbstractTypedTree t = (AbstractTypedTree) v.type(); - assertThat(typeBinding(t)).isNotNull(); - assertThat(sema(cu).declarations.get(variableBinding(v))).isSameAs(v); + assertThat(type(t)).isNotNull(); + assertThat(SemanticTestSupport.declaration(symbol(v))).isSameAs(v); } @Test @@ -1413,8 +1366,8 @@ void declaration_annotation_member() { JavaTree.CompilationUnitTreeImpl cu = test("@interface A { String m(); }"); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); - assertThat(methodBinding(m)).isNotNull(); - assertThat(sema(cu).declarations.get(methodBinding(m))).isSameAs(m); + assertThat(method(m)).isNotNull(); + assertThat(SemanticTestSupport.declaration(method(m))).isSameAs(m); } @ParameterizedTest(name="[{index}] Type bindings of variable v should not be null in \"{0}\"") @@ -1430,7 +1383,7 @@ void test_abstract_type_tree_is_not_null(String source) { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); VariableTreeImpl v = (VariableTreeImpl) c.members().get(0); AbstractTypedTree t = (AbstractTypedTree) v.type(); - assertThat(typeBinding(t)).isNotNull(); + assertThat(type(t)).isNotNull(); } @Test @@ -1439,11 +1392,11 @@ void type_array() { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); VariableTreeImpl v = (VariableTreeImpl) c.members().get(0); JavaTree.ArrayTypeTreeImpl t = (JavaTree.ArrayTypeTreeImpl) v.type(); - assertThat(typeBinding(t)).isNotNull(); - assertThat(typeBinding(t).getDimensions()).isEqualTo(2); + assertThat(type(t)).isNotNull(); + assertThat(SemanticTestSupport.dimensions(type(t))).isEqualTo(2); t = (JavaTree.ArrayTypeTreeImpl) t.type(); - assertThat(typeBinding(t)).isNotNull(); - assertThat(typeBinding(t).getDimensions()).isEqualTo(1); + assertThat(type(t)).isNotNull(); + assertThat(SemanticTestSupport.dimensions(type(t))).isEqualTo(1); } @Test @@ -1453,7 +1406,7 @@ void type_wildcard() { VariableTreeImpl v = (VariableTreeImpl) c.members().get(0); ParameterizedTypeTree p = (ParameterizedTypeTree) v.type(); AbstractTypedTree t = ((AbstractTypedTree) p.typeArguments().get(0)); - assertThat(typeBinding(t)).isNotNull(); + assertThat(type(t)).isNotNull(); } /** @@ -1495,11 +1448,11 @@ void type_try_with_resource() { TryStatementTree s = (TryStatementTree) m.block().body().get(0); VariableTreeImpl v = (VariableTreeImpl) s.resourceList().get(0); AbstractTypedTree t = (AbstractTypedTree) v.type(); - assertThat(typeBinding(t)).isNotNull(); - JType t2 = (JType) v.symbol().type(); + assertThat(type(t)).isNotNull(); + Type t2 = v.symbol().type(); assertThat(t2).isNotNull(); assertThat(t2.isUnknown()).isTrue(); - assertThat(t2.typeBinding).isNotNull(); + assertThat(t2).isSameAs(v.symbol().type()); } { // C not recognized as closeable @@ -1509,7 +1462,7 @@ void type_try_with_resource() { TryStatementTree s = (TryStatementTree) m.block().body().get(0); VariableTreeImpl v = (VariableTreeImpl) s.resourceList().get(0); AbstractTypedTree t = (AbstractTypedTree) v.type(); - assertThat(typeBinding(t)).isNotNull(); + assertThat(type(t)).isNotNull(); Type type = v.symbol().type(); assertThat(type).isNotNull(); assertThat(type.isUnknown()).isTrue(); @@ -1524,7 +1477,7 @@ void type_union() { TryStatementTree s = (TryStatementTree) m.block().body().get(0); VariableTreeImpl v = (VariableTreeImpl) s.catches().get(0).parameter(); AbstractTypedTree t = (AbstractTypedTree) v.type(); - assertThat(typeBinding(t)).isNotNull(); + assertThat(type(t)).isNotNull(); Type symbolType = t.symbolType(); assertThat(symbolType).isNotNull(); assertThat(symbolType.isUnknown()).isFalse(); @@ -1542,7 +1495,7 @@ void type_intersection_in_cast_expression() { MethodTree m = (MethodTree) c.members().get(0); VariableTreeImpl v = (VariableTreeImpl) m.block().body().get(0); AbstractTypedTree t = (AbstractTypedTree) v.type(); - assertThat(typeBinding(t)).isNotNull(); + assertThat(type(t)).isNotNull(); Type symbolType = t.symbolType(); assertThat(symbolType).isNotNull(); assertThat(symbolType.fullyQualifiedName()).isEqualTo("java.lang.AutoCloseable & java.lang.Cloneable & java.lang.Comparable"); @@ -1583,7 +1536,7 @@ void type_var() { MethodTree m = (MethodTree) c.members().get(0); VariableTreeImpl v = (VariableTreeImpl) m.block().body().get(0); AbstractTypedTree t = (AbstractTypedTree) v.type(); - assertThat(typeBinding(t)).isNotNull(); + assertThat(type(t)).isNotNull(); } @Test @@ -1592,11 +1545,11 @@ void type_extra_dimensions() { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); VariableTreeImpl v = (VariableTreeImpl) c.members().get(0); JavaTree.ArrayTypeTreeImpl t = (JavaTree.ArrayTypeTreeImpl) v.type(); - assertThat(typeBinding(t)).isNotNull(); - assertThat(typeBinding(t).getDimensions()).isEqualTo(2); + assertThat(type(t)).isNotNull(); + assertThat(SemanticTestSupport.dimensions(type(t))).isEqualTo(2); t = (JavaTree.ArrayTypeTreeImpl) t.type(); - assertThat(typeBinding(t)).isNotNull(); - assertThat(typeBinding(t).getDimensions()).isEqualTo(1); + assertThat(type(t)).isNotNull(); + assertThat(SemanticTestSupport.dimensions(type(t))).isEqualTo(1); } @Test @@ -1606,8 +1559,8 @@ void type_vararg() { MethodTree m = (MethodTree) c.members().get(0); VariableTreeImpl v = (VariableTreeImpl) m.parameters().get(0); AbstractTypedTree t = (AbstractTypedTree) v.type(); - assertThat(typeBinding(t)).isNotNull(); - assertThat(typeBinding(t).getDimensions()).isEqualTo(2); + assertThat(type(t)).isNotNull(); + assertThat(SemanticTestSupport.dimensions(type(t))).isEqualTo(2); } @Test @@ -1615,7 +1568,7 @@ void symbol_unknown() { JavaTree.CompilationUnitTreeImpl cu = test("class A implements UnknownInterface { }"); ClassTree c = (ClassTree) cu.types().get(0); IdentifierTreeImpl i = (IdentifierTreeImpl) c.superInterfaces().get(0); - Symbol s = sema(cu).typeSymbol(Objects.requireNonNull((ITypeBinding) binding(i))); + Symbol s = Objects.requireNonNull(symbol(i).type()).symbol(); assertThat(s.isUnknown()) .isEqualTo(i.symbol().isUnknown()) .isTrue(); @@ -1636,10 +1589,10 @@ void annotation_on_type() { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); VariableTreeImpl parameter = (VariableTreeImpl) m.parameters().get(0); - assertThat(sema(cu).variableSymbol(variableBinding(parameter)).metadata().annotations().size()) + assertThat((symbol(parameter)).metadata().annotations().size()) .isEqualTo(parameter.symbol().metadata().annotations().size()) .isEqualTo(1); - assertThat(JUtils.parameterAnnotations(sema(cu).methodSymbol(Objects.requireNonNull(methodBinding(m))), 0).annotations().size()) + assertThat(JUtils.parameterAnnotations(Objects.requireNonNull(method(m)), 0).annotations().size()) .isEqualTo(JUtils.parameterAnnotations(m.symbol(), 0).annotations().size()) .isEqualTo(1); } @@ -1658,12 +1611,10 @@ void annotation_on_var_type_local_variable() { } /** - * @see org.eclipse.jdt.core.dom.LabeledStatement */ @Nested class Labels { /** - * @see org.eclipse.jdt.core.dom.BreakStatement */ @Test void statement_break() { @@ -1681,7 +1632,7 @@ void statement_break() { .isInstanceOf(Symbol.LabelSymbol.class) .isInstanceOf(Symbol.class) .isSameAs(l.labelSymbol); - assertThat(binding(i)) + assertThat(symbol(i)) .isNull(); assertThat(i.symbol()) @@ -1697,7 +1648,6 @@ void statement_break() { } /** - * @see org.eclipse.jdt.core.dom.ContinueStatement */ @Test void statement_continue() { @@ -1712,7 +1662,7 @@ void statement_continue() { assertThat(l.labelSymbol) .isNotNull() .isSameAs(i.labelSymbol); - assertThat(binding(i)) + assertThat(symbol(i)) .isNull(); assertThat(l.labelSymbol.declaration) .isSameAs(i.labelSymbol.declaration) @@ -1734,7 +1684,7 @@ void nested() { assertThat(l1.labelSymbol) .isNotNull() .isSameAs(i1.labelSymbol); - assertThat(binding(i1)) + assertThat(symbol(i1)) .isNull(); assertThat(l1.labelSymbol.declaration) .isSameAs(i1.labelSymbol.declaration) @@ -1752,7 +1702,7 @@ void nested() { assertThat(l2.labelSymbol) .isNotNull() .isSameAs(i2.labelSymbol); - assertThat(binding(i2)) + assertThat(symbol(i2)) .isNull(); assertThat(l2.labelSymbol.declaration) .isSameAs(i2.labelSymbol.declaration) @@ -1807,12 +1757,17 @@ private static JavaTree.CompilationUnitTreeImpl test(String source) { @Test void not_need_to_skip_implicit_break_statement() { final String source = "class C { void m() { switch (0) { case 0 -> { } } } }"; - CompilationUnit cu = createAST(source); - TypeDeclaration c = (TypeDeclaration) cu.types().get(0); - MethodDeclaration m = c.getMethods()[0]; - SwitchStatement s = (SwitchStatement) m.getBody().statements().get(0); - Block block = (Block) s.statements().get(1); - assertThat(block.statements()).isEmpty(); + var configuration = new org.sonar.java.psi.JavaPsiConfiguration(null, java.util.List.of(), 26, true, true); + var snapshot = new org.sonar.java.psi.JavaPsiEnvironment.SourceSnapshot(java.nio.file.Path.of("C.java"), source, java.nio.charset.StandardCharsets.UTF_8); + try (var environment = org.sonar.java.psi.JavaPsiEnvironment.open(configuration, java.util.List.of(snapshot))) { + environment.read((project, files) -> { + var statement = (com.intellij.psi.PsiSwitchStatement) files.getFirst().getClasses()[0].getMethods()[0].getBody().getStatements()[0]; + var rule = (com.intellij.psi.PsiSwitchLabeledRuleStatement) statement.getBody().getStatements()[0]; + var block = (com.intellij.psi.PsiBlockStatement) rule.getBody(); + assertThat(block.getCodeBlock().getStatements()).isEmpty(); + return null; + }); + } CompilationUnitTree compilationUnit = test(source); ClassTree cls = (ClassTree) compilationUnit.types().get(0); @@ -1822,26 +1777,6 @@ void not_need_to_skip_implicit_break_statement() { assertThat(blockStatement.body()).isEmpty(); } - private CompilationUnit createAST(String source) { - JavaVersion version = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION; - ASTParser astParser = ASTParser.newParser(AST.getJLSLatest()); - Map options = new HashMap<>(JavaCore.getOptions()); - JavaCore.setComplianceOptions(version.effectiveJavaVersionAsString(), options); - options.put(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, "enabled"); - astParser.setCompilerOptions(options); - astParser.setEnvironment( - new String[]{}, - new String[]{}, - new String[]{}, - true - ); - astParser.setUnitName("File.java"); - astParser.setResolveBindings(true); - astParser.setBindingsRecovery(true); - astParser.setSource(source.toCharArray()); - return (CompilationUnit) astParser.createAST(null); - } - @Test void super_constructor_external_inner_class() { final String source = """ @@ -1966,9 +1901,9 @@ int consume(C c) { assertNotEquals(symbol1, p2.symbol()); Symbol owner1 = symbol1.owner(); - assertTrue(owner1 instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()); + assertTrue(SemanticTestSupport.isLambda(owner1)); Symbol owner2 = symbol2.owner(); - assertTrue(owner2 instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()); + assertTrue(SemanticTestSupport.isLambda(owner2)); assertNotEquals(owner1, owner2); } @@ -1993,7 +1928,7 @@ class C { Symbol jOwner = j.symbol().owner(); Symbol kOwner = k.symbol().owner(); assertNotEquals(jOwner, kOwner); - assertTrue(iOwner instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()); + assertTrue(SemanticTestSupport.isLambda(iOwner)); } @Test @@ -2038,12 +1973,12 @@ interface F extends java.util.function.Consumer {} var k = (VariableTree) classTree.members().get(0); Symbol s1 = ((LambdaExpressionTree) k.initializer()).parameters().get(0).symbol(); Symbol s1Owner = s1.owner(); - assertThat(s1Owner instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()).isTrue(); + assertThat(SemanticTestSupport.isLambda(s1Owner)).isTrue(); var j = (VariableTree) classTree.members().get(1); Symbol s2 = ((LambdaExpressionTree) j.initializer()).parameters().get(0).symbol(); Symbol s2Owner = s2.owner(); - assertThat(s2Owner instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()).isTrue(); + assertThat(SemanticTestSupport.isLambda(s2Owner)).isTrue(); assertNotEquals(s1Owner, s2Owner); // For sanity, check that the symbols are not equal @@ -2085,9 +2020,9 @@ void f2() { Symbol ownerC = pOfC.symbol().owner(); Symbol ownerB = pOfB.symbol().owner(); - assertThat(ownerA instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()).isTrue(); - assertThat(ownerB instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()).isTrue(); - assertThat(ownerC instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()).isTrue(); + assertThat(SemanticTestSupport.isLambda(ownerA)).isTrue(); + assertThat(SemanticTestSupport.isLambda(ownerB)).isTrue(); + assertThat(SemanticTestSupport.isLambda(ownerC)).isTrue(); assertNotEquals(ownerA, ownerC); assertNotEquals(ownerA, ownerB); assertNotEquals(ownerC, ownerB); diff --git a/java-frontend/src/test/java/org/sonar/java/model/JParserTest.java b/java-frontend/src/test/java/org/sonar/java/model/JParserTest.java index ca1818ce8b3..efacc9fe851 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JParserTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JParserTest.java @@ -40,13 +40,6 @@ import java.util.jar.Manifest; import org.apache.commons.io.FileUtils; import org.eclipse.core.runtime.OperationCanceledException; -import org.eclipse.jdt.core.JavaCore; -import org.eclipse.jdt.core.dom.AST; -import org.eclipse.jdt.core.dom.ASTParser; -import org.eclipse.jdt.core.dom.CompilationUnit; -import org.eclipse.jdt.internal.compiler.parser.TerminalToken; -import org.eclipse.jdt.internal.formatter.Token; -import org.eclipse.jdt.internal.formatter.TokenManager; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.junit.jupiter.api.io.TempDir; @@ -99,8 +92,6 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; -import static org.sonar.java.model.JParser.convertTokenTypeToCommentKind; -import static org.sonar.java.model.JParser.isComment; import static org.sonar.java.model.JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION; import static org.sonar.java.model.JParserConfig.Mode.BATCH; import static org.sonar.java.model.JParserConfig.Mode.FILE_BY_FILE; @@ -132,8 +123,7 @@ void should_throw_RecognitionException_in_case_of_syntax_error() { void should_recover_if_parser_fails() { String version = "12"; List classpath = Collections.singletonList(new File("unknownFile")); - ASTParser astParser = FILE_BY_FILE.create(JavaVersionImpl.fromString(version), classpath).astParser(); - assertThrows(RecognitionException.class, () -> JParser.parse(astParser, version, "A", "class A { }")); + assertThrows(RecognitionException.class, () -> FrontendParser.parse(JavaVersionImpl.fromString(version), classpath, "A", "class A {")); } @Test @@ -507,25 +497,12 @@ record Box(int value) {} } @Test - void test_first_index_of_tokens_in_eclipse_ast() { - String version = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION.effectiveJavaVersionAsString(); - String unitName = "C.java"; - String source = "class C { }"; - - ASTParser astParser = ASTParser.newParser(AST.getJLSLatest()); - JavaCore.setComplianceOptions(version, JavaCore.getOptions()); - astParser.setResolveBindings(true); - astParser.setUnitName(unitName); - astParser.setSource(source.toCharArray()); - CompilationUnit compilationUnit = (CompilationUnit) astParser.createAST(null); - TokenManager tokenManager = JParser.createTokenManager(version, unitName, source); - - assertThat(JParser.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNameIdentifier, TerminalToken.TokenNameLBRACE)).isEqualTo(1); - assertThat(JParser.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNameLBRACE, TerminalToken.TokenNameIdentifier)).isEqualTo(1); - assertThat(JParser.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNameRBRACE, TerminalToken.TokenNameLBRACE)).isEqualTo(2); - assertThatThrownBy(() -> JParser.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNamebreak, TerminalToken.TokenNameconst)) - .isInstanceOf(IllegalStateException.class) - .hasMessage("Failed to find token TokenNamebreak or TokenNameconst in the tokens of a org.eclipse.jdt.core.dom.CompilationUnit"); + void test_token_search_in_psi_index() { + var tokens = new PsiTokenIndex("class C { }"); + assertThat(tokens.find(0, 11, "C", false)).isSameAs(tokens.lexemes().get(1).token()); + assertThat(tokens.find(0, 11, "{", false)).isSameAs(tokens.lexemes().get(2).token()); + assertThat(tokens.find(0, 11, "}", true)).isSameAs(tokens.lexemes().get(3).token()); + assertThatThrownBy(() -> tokens.find(0, 11, "break", false)).isInstanceOf(IllegalArgumentException.class).hasMessage("Missing token 'break' in [0, 11)"); } @Test @@ -544,46 +521,21 @@ class A { void foo() {} } """; - TokenManager tokens = JParser.createTokenManager(version, unitName, source); - - assertThat(tokens.size()).isEqualTo(15); - - Token token0 = tokens.get(0); - assertThat(token0.toString(source)).isEqualTo("class"); - assertThat(token0.isComment()).isFalse(); - assertThat(isComment(token0)).isFalse(); - assertThatThrownBy(() -> convertTokenTypeToCommentKind(token0)) - .isInstanceOf(IllegalStateException.class) - .hasMessage("Unexpected value: TokenNameclass"); - - Token token3 = tokens.get(3); - assertThat(token3.toString(source)).isEqualTo("// line comment"); - assertThat(token3.isComment()).isTrue(); - assertThat(isComment(token3)).isTrue(); - assertThat(convertTokenTypeToCommentKind(token3)).isEqualTo(CommentKind.LINE); - - Token token4 = tokens.get(4); - assertThat(token4.toString(source)).isEqualTo("/* block comment */"); - assertThat(token4.isComment()).isTrue(); - assertThat(isComment(token4)).isTrue(); - assertThat(convertTokenTypeToCommentKind(token4)).isEqualTo(CommentKind.BLOCK); - - Token token5 = tokens.get(5); - assertThat(token5.toString(source)).isEqualTo("/// markdown comment 1\n /// markdown comment 2"); - assertThat(token5.isComment()).isTrue(); - assertThat(isComment(token5)).isTrue(); - assertThat(convertTokenTypeToCommentKind(token5)).isEqualTo(CommentKind.MARKDOWN); - - Token token6 = tokens.get(6); - assertThat(token6.toString(source)).isEqualTo("/**\n * javadoc comment\n */"); - assertThat(token6.isComment()).isTrue(); - assertThat(isComment(token6)).isTrue(); - assertThat(convertTokenTypeToCommentKind(token6)).isEqualTo(CommentKind.JAVADOC); - - Token token7 = tokens.get(7); - assertThat(token7.toString(source)).isEqualTo("void"); - assertThat(token7.isComment()).isFalse(); - assertThat(isComment(token7)).isFalse(); + var tokens = new PsiTokenIndex(source).lexemes(); + assertThat(tokens).hasSize(11); + assertThat(tokens.getFirst().token().text()).isEqualTo("class"); + assertThat(tokens.getFirst().token().trivias()).isEmpty(); + var comments = tokens.get(3).token().trivias(); + assertThat(comments).hasSize(4); + assertThat(comments.get(0).comment()).isEqualTo("// line comment"); + assertThat(comments.get(0).commentKind()).isEqualTo(CommentKind.LINE); + assertThat(comments.get(1).comment()).isEqualTo("/* block comment */"); + assertThat(comments.get(1).commentKind()).isEqualTo(CommentKind.BLOCK); + assertThat(comments.get(2).comment()).isEqualTo("/// markdown comment 1\n /// markdown comment 2"); + assertThat(comments.get(2).commentKind()).isEqualTo(CommentKind.MARKDOWN); + assertThat(comments.get(3).comment()).isEqualTo("/**\n * javadoc comment\n */"); + assertThat(comments.get(3).commentKind()).isEqualTo(CommentKind.JAVADOC); + assertThat(tokens.get(3).token().text()).isEqualTo("void"); } @Test @@ -702,11 +654,27 @@ void successful_batch_mode_with_missing_analyzed_files_should_continue_file_by_f TestUtils.inputFile("src/test/files/metrics/Classes.java"), TestUtils.inputFile("src/test/files/metrics/Methods.java")); BiConsumer doNothingAction = (inputFile, result) -> {}; - JParserConfig config = spy(JParserConfig.Mode.BATCH - .create(MAXIMUM_SUPPORTED_JAVA_VERSION, List.of(), false)); - // Return a lazy ASTParser that do nothing to ensure that we have not analyzed files - ASTParser astParser = mock(ASTParser.class); - when(config.astParser()).thenReturn(astParser); + JParserConfig config = new JParserConfig.Batch(MAXIMUM_SUPPORTED_JAVA_VERSION, List.of(), false) { + @Override + FrontendBackend backend() { + FrontendBackend delegate = super.backend(); + return configuration -> new FrontendSession() { + private final FrontendSession session = delegate.open(configuration); + { + own(session::close); + } + + @Override + JavaTree.CompilationUnitTreeImpl parse(String unitName, String source) { + return session.parse(unitName, source); + } + + @Override + void parseBatch(FrontendBatch inputs, org.sonar.java.ProgressMonitor monitor, BiConsumer action) { + } + }; + } + }; config.parse(inputFiles, () -> false, new AnalysisProgress(inputFiles.size()), doNothingAction); @@ -830,11 +798,11 @@ public BatchWithException() { } @Override - public ASTParser astParser() { + FrontendBackend backend() { if (!exceptions.isEmpty()) { throw exceptions.pop(); } - return super.astParser(); + return super.backend(); } } diff --git a/java-frontend/src/test/java/org/sonar/java/model/JSemaRegressionTest.java b/java-frontend/src/test/java/org/sonar/java/model/JSemaRegressionTest.java new file mode 100644 index 00000000000..67823626dcc --- /dev/null +++ b/java-frontend/src/test/java/org/sonar/java/model/JSemaRegressionTest.java @@ -0,0 +1,244 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import org.junit.jupiter.api.Test; +import org.sonar.java.psi.JavaPsiEnvironment; +import org.sonar.plugins.java.api.semantic.Symbol; +import org.sonar.plugins.java.api.semantic.Type; +import org.sonar.plugins.java.api.tree.BaseTreeVisitor; +import org.sonar.plugins.java.api.tree.ClassTree; +import org.sonar.plugins.java.api.tree.MethodInvocationTree; +import org.sonar.plugins.java.api.tree.MethodTree; +import org.sonar.plugins.java.api.tree.Tree; +import org.sonar.plugins.java.api.tree.VariableTree; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +class JSemaRegressionTest { + @Test + void basic_types_and_selected_runtime_lookup() { + try (var fixture = open("")) { + var sema = fixture.tree().sema; + assertThat(sema.getClassType("java.lang.String")).isSameAs(sema.getClassType("java.lang.String")); + assertThat(sema.getClassType("java.util.Map$Entry[][]").isArray()).isTrue(); + assertThat(sema.getClassType("missing.Type")).isSameAs(Type.UNKNOWN); + assertThat(sema.getClassType("int").primitiveWrapperType().is("java.lang.Integer")).isTrue(); + assertThat(sema.getClassType("java.lang.Integer").primitiveType().is("int")).isTrue(); + assertThat(sema.getClassType("int").isSubtypeOf("long")).isFalse(); + assertThat(sema.getClassType("java.lang.String").isSubtypeOf("java.lang.Object")).isTrue(); + } + } + + @Test + void declarations_usages_and_generic_calls() { + try (var fixture = open("class A { T id(T t) { return t; } void use() { String s = id(\"x\"); } }")) { + var cls = (ClassTree) fixture.tree().types().getFirst(); + var method = (MethodTree) cls.members().getFirst(); + assertThat(cls.symbol().declaration()).isSameAs(cls); + assertThat(method.symbol().declaration()).isSameAs(method); + assertThat(method.symbol().parameterTypes()).extracting(Type::name).containsExactly("T"); + assertThat(method.symbol().signature()).isEqualTo("A#id(Ljava/lang/Object;)Ljava/lang/Object;"); + assertThat(method.parameters().getFirst().symbol().usages()).hasSize(1); + assertThat(method.parameters().getFirst().symbol().owner()).isSameAs(method.symbol()); + } + } + + @Test + void recursive_bounds_and_substituted_hierarchies() { + try (var fixture = open("class A> extends java.util.ArrayList {}")) { + var cls = (ClassTree) fixture.tree().types().getFirst(); + assertThat(cls.symbol().superClass().typeArguments()).extracting(Type::fullyQualifiedName).containsExactly("java.lang.String"); + assertThat(cls.symbol().superTypes()).anyMatch(t -> t.is("java.util.List")); + assertThat(cls.symbol().type()).isSameAs(cls.symbol().type()); + } + } + + @Test + void constants_and_metadata() { + try (var fixture = open("@Deprecated class A { static final char C = 'a'; @Deprecated String value; }")) { + var cls = (ClassTree) fixture.tree().types().getFirst(); + var constant = (VariableTree) cls.members().getFirst(); + assertThat(((Symbol.VariableSymbol) constant.symbol()).constantValue()).contains(97); + assertThat(cls.symbol().metadata().isAnnotatedWith("java.lang.Deprecated")).isTrue(); + assertThat(((VariableTree) cls.members().get(1)).symbol().metadata().isAnnotatedWith("java.lang.Deprecated")).isTrue(); + } + } + + @Test + void lazy_queries_are_owned_by_the_environment() { + var fixture = open("class A {}"); + var cls = (ClassTree) fixture.tree().types().getFirst(); + var sema = fixture.tree().sema; + assertThat(sema.getEnvironmentCleaner()).isSameAs(sema.getEnvironmentCleaner()); + assertThat(cls.symbol().name()).isEqualTo("A"); + fixture.close(); + fixture.close(); + assertThatThrownBy(() -> cls.symbol().name()).isInstanceOf(IllegalStateException.class).hasMessage("PSI environment is closed"); + } + + @Test + void generic_invocations_retain_substitutions_and_share_declarations() { + try (var fixture = open("class A { T id(T p) { return p; } void use() { id(\"one\"); id(\"two\"); id(42); } }")) { + var calls = calls(fixture.tree()); + assertThat(calls).hasSize(3); + var first = calls.getFirst().methodSymbol(); + assertThat(first).isSameAs(calls.get(1).methodSymbol()).isNotEqualTo(calls.get(2).methodSymbol()); + assertThat(first.parameterTypes()).extracting(Type::fullyQualifiedName).containsExactly("java.lang.String"); + assertThat(first.declarationParameters()).extracting(s -> s.type().name()).containsExactly("T"); + assertThat(first.declaration()).isSameAs(calls.get(2).methodSymbol().declaration()); + assertThat(first.usages()).hasSize(3); + } + } + + @Test + void multi_file_resolution_keeps_declarations_and_usages_file_local() { + var sources = List.of(source("A.java", "class A { void use(B b) { b.id(\"one\"); } }"), + source("B.java", "class B { T id(T value) { return value; } }")); + try (var fixture = PsiSemanticTestSupport.open(sources, List.of(), JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION)) { + var first = calls(fixture.trees().getFirst()).getFirst().methodSymbol(); + var second = ((MethodTree) ((ClassTree) fixture.trees().get(1).types().getFirst()).members().getFirst()).symbol(); + assertThat(first.isUnknown()).isFalse(); + assertThat(first.declaration()).isNull(); + assertThat(first.usages()).hasSize(1); + assertThat(second.declaration()).isNotNull(); + assertThat(second.usages()).isEmpty(); + assertThat(first.declarationParameters()).extracting(Symbol::name).containsExactly("arg0"); + assertThat(first.declarationParameters().getFirst().declaration()).isNull(); + assertThat(fixture.trees().getFirst().sema.getEnvironmentCleaner()).isSameAs(fixture.trees().get(1).sema.getEnvironmentCleaner()); + } + } + + @Test + void unicode_normalization_preserves_resolution_and_physical_ranges() { + try (var fixture = open("class A { String \\u0076 = \"x\"; String use() { return \\u0076; } }")) { + var cls = (ClassTree) fixture.tree().types().getFirst(); + var field = (VariableTree) cls.members().getFirst(); + assertThat(field.symbol().name()).isEqualTo("v"); + assertThat(field.symbol().usages()).hasSize(1); + assertThat(field.symbol().usages().getFirst().symbol()).isSameAs(field.symbol()); + assertThat(field.symbol().usages().getFirst().identifierToken().text()).isEqualTo("\\u0076"); + assertThat(field.symbol().usages().getFirst().identifierToken().range().end().columnOffset() + - field.symbol().usages().getFirst().identifierToken().range().start().columnOffset()).isEqualTo(6); + } + } + + @Test + void repaired_resource_declarations_keep_their_enclosing_resolution_context() { + try (var fixture = open("class A { void use(java.io.Closeable[] input) { try (java.io.Closeable resource[] = input) { resource.toString(); } } }")) { + var cls = (ClassTree) fixture.tree().types().getFirst(); + var method = (MethodTree) cls.members().getFirst(); + var tried = (org.sonar.plugins.java.api.tree.TryStatementTree) method.block().body().getFirst(); + var resource = (VariableTree) tried.resourceList().getFirst(); + assertThat(resource.type().symbolType().isArray()).isTrue(); + assertThat(resource.symbol().owner()).isSameAs(method.symbol()); + assertThat(method.parameters().getFirst().symbol().usages()).hasSize(1); + } + } + + @Test + void suppressing_the_semantic_model_retains_existing_tree_attachments() { + try (var fixture = open("class A { int value; }")) { + var cls = (ClassTree) fixture.tree().types().getFirst(); + fixture.tree().sema = null; + assertThat(cls.symbol().name()).isEqualTo("A"); + assertThat(((VariableTree) cls.members().getFirst()).type().symbolType().is("int")).isTrue(); + } + } + + @Test + void package_metadata_selects_binary_info_instead_of_source_overlay() throws Exception { + var sources = List.of(source("package-info.java", "@Deprecated package org.sonar.java.resolve.targets;"), + source("A.java", "package org.sonar.java.resolve.targets; class A {}")); + var annotations = new java.io.File(javax.annotation.ParametersAreNonnullByDefault.class.getProtectionDomain().getCodeSource().getLocation().toURI()); + try (var fixture = PsiSemanticTestSupport.open(sources, List.of(new java.io.File("target/test-classes"), annotations), JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION)) { + var cls = (ClassTree) fixture.trees().get(1).types().getFirst(); + assertThat(cls.symbol().owner().metadata().annotations()).hasSize(1); + assertThat(cls.symbol().owner().metadata().annotations()).extracting(a -> a.symbol().type().fullyQualifiedName()) + .containsExactly("javax.annotation.ParametersAreNonnullByDefault"); + assertThat(cls.symbol().owner().metadata().isAnnotatedWith("java.lang.Deprecated")).isFalse(); + } + } + + @Test + void explicit_runtime_archive_excludes_the_host_runtime(@org.junit.jupiter.api.io.TempDir Path directory) throws Exception { + var runtime = directory.resolve("rt.jar"); + try (var output = new java.util.jar.JarOutputStream(java.nio.file.Files.newOutputStream(runtime))) { + output.finish(); + } + try (var fixture = PsiSemanticTestSupport.open("A.java", "interface A {}", List.of(runtime.toFile()), JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION)) { + var sema = fixture.tree().sema; + assertThat(sema.getClassType("java.lang.String")).isSameAs(Type.UNKNOWN); + assertThat(sema.getClassType("int").primitiveWrapperType()).isNull(); + assertThat(((ClassTree) fixture.tree().types().getFirst()).symbol().superClass()).isSameAs(Type.UNKNOWN); + } + } + + @Test + void canonical_factories_are_isolated_between_sessions() { + try (var left = open("class A {}" ); var right = open("class A {}")) { + var leftType = ((ClassTree) left.tree().types().getFirst()).symbol().type(); + var rightType = ((ClassTree) right.tree().types().getFirst()).symbol().type(); + assertThat(leftType).isNotSameAs(rightType).isEqualTo(rightType).hasSameHashCodeAs(rightType); + assertThat(leftType.symbol()).isNotSameAs(rightType.symbol()).isEqualTo(rightType.symbol()); + left.close(); + assertThat(rightType.name()).isEqualTo("A"); + assertThat(right.tree().sema.getClassType("java.lang.String").name()).isEqualTo("String"); + } + } + + @Test + void capture_identity_includes_parameter_and_context() { + try (var fixture = open("class Pair {}")) { + var sema = (JSema) fixture.tree().sema; + sema.read(() -> { + var cls = sema.file.getClasses()[0]; + var wildcard = com.intellij.psi.PsiWildcardType.createUnbounded(com.intellij.psi.PsiManager.getInstance(sema.project)); + var first = com.intellij.psi.PsiCapturedWildcardType.create(wildcard, cls, cls.getTypeParameters()[0]); + var second = com.intellij.psi.PsiCapturedWildcardType.create(wildcard, cls, cls.getTypeParameters()[1]); + var otherContext = com.intellij.psi.PsiCapturedWildcardType.create(wildcard, cls.getNameIdentifier(), cls.getTypeParameters()[0]); + assertThat(sema.type(first)).isSameAs(sema.type(first)).isNotEqualTo(sema.type(second)).isNotEqualTo(sema.type(otherContext)); + return null; + }); + } + } + + private static List calls(Tree root) { + List result = new ArrayList<>(); + root.accept(new BaseTreeVisitor() { + @Override + public void visitMethodInvocation(MethodInvocationTree tree) { + result.add(tree); + super.visitMethodInvocation(tree); + } + }); + return result; + } + + private static JavaPsiEnvironment.SourceSnapshot source(String name, String contents) { + return new JavaPsiEnvironment.SourceSnapshot(Path.of(name), contents, StandardCharsets.UTF_8); + } + + private static PsiSemanticTestSupport open(String source) { + return PsiSemanticTestSupport.open("File.java", source, List.of(), JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION); + } +} diff --git a/java-frontend/src/test/java/org/sonar/java/model/JSemaTest.java b/java-frontend/src/test/java/org/sonar/java/model/JSemaTest.java index 1b524ad8858..c28410b1684 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JSemaTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JSemaTest.java @@ -16,8 +16,6 @@ */ package org.sonar.java.model; -import java.util.Objects; -import org.eclipse.jdt.core.dom.ITypeBinding; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.sonar.java.test.TestResourceScope; @@ -39,44 +37,42 @@ void testGetClassTypeUnknown() { @Test void type() { - ITypeBinding typeBinding = Objects.requireNonNull(sema.resolveType("int")); - assertThat(sema.type(typeBinding)) - .isNotNull() - .isSameAs(sema.type(typeBinding)); + Type type = sema.getClassType("int"); + assertThat(type).isNotNull().isSameAs(sema.getClassType("int")); } @Test void resolveType() { assertAll( () -> - assertThat(sema.resolveType("Nonexistent")) - .isNull(), + assertThat(sema.getClassType("Nonexistent")) + .isSameAs(Type.UNKNOWN), () -> - assertThat(sema.resolveType("void")) - .isNotNull(), + assertThat(sema.getClassType("void")) + .isNotSameAs(Type.UNKNOWN), () -> - assertThat(sema.resolveType("java.util.Map")) - .isNotNull(), + assertThat(sema.getClassType("java.util.Map")) + .isNotSameAs(Type.UNKNOWN), () -> - assertThat(sema.resolveType("java.util.Map$Entry")) - .isNotNull(), + assertThat(sema.getClassType("java.util.Map$Entry")) + .isNotSameAs(Type.UNKNOWN), () -> - assertThat(sema.resolveType("java.util.Map$Entry[][]")) - .isNotNull() + assertThat(sema.getClassType("java.util.Map$Entry[][]")) + .isNotSameAs(Type.UNKNOWN) ); } @Test void resolvePackageAnnotations() { - assertThat(sema.resolvePackageAnnotations("org.sonar.java.resolve.targets")) + assertThat(sema.getClassType("org.sonar.java.resolve.targets.ClassWithConstants").symbol().owner().metadata().annotations()) .hasSize(1); } - private JSema sema; + private org.sonar.plugins.java.api.semantic.Sema sema; @BeforeEach void setup() { - sema = EcjTestSupport.sema(SemanticFixture.scoped("", java.util.List.of(new java.io.File("target/test-classes"))).tree()); + sema = SemanticFixture.scoped("", java.util.List.of(new java.io.File("target/test-classes"))).tree().sema; } } diff --git a/java-frontend/src/test/java/org/sonar/java/model/JSymbolTest.java b/java-frontend/src/test/java/org/sonar/java/model/JSymbolTest.java index bcf309e0e90..82df0f0690f 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JSymbolTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JSymbolTest.java @@ -16,11 +16,6 @@ */ package org.sonar.java.model; -import org.eclipse.jdt.core.dom.AST; -import org.eclipse.jdt.core.dom.ASTParser; -import org.eclipse.jdt.core.dom.CompilationUnit; -import org.eclipse.jdt.core.dom.IBinding; -import org.eclipse.jdt.core.dom.IVariableBinding; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -47,15 +42,11 @@ import org.sonar.plugins.java.api.tree.VariableTree; import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -import static org.sonar.java.model.EcjTestSupport.methodBinding; -import static org.sonar.java.model.EcjTestSupport.sema; -import static org.sonar.java.model.EcjTestSupport.typeBinding; -import static org.sonar.java.model.EcjTestSupport.variableBinding; import static org.sonar.java.model.assertions.SymbolAssert.assertThat; @TestResourceScope.Scoped @@ -68,13 +59,13 @@ void name() { MethodTreeImpl constructor = (MethodTreeImpl) c.members().get(0); MethodTreeImpl method = (MethodTreeImpl) c.members().get(1); - assertThat(sema(cu).typeSymbol(typeBinding(c))) + assertThat(SemanticTestSupport.type(c).symbol()) .hasSameNameAs(c.symbol()) .hasName("C"); - assertThat(sema(cu).methodSymbol(methodBinding(constructor))) + assertThat(SemanticTestSupport.method(constructor)) .hasSameNameAs(constructor.symbol()) .hasName(""); - assertThat(sema(cu).methodSymbol(methodBinding(method))) + assertThat(SemanticTestSupport.method(method)) .hasSameNameAs(method.symbol()) .hasName("m"); } @@ -90,39 +81,39 @@ void owner() { ClassTreeImpl c3 = (ClassTreeImpl) m.block().body().get(0); VariableTreeImpl u = (VariableTreeImpl) c3.members().get(0); - assertThat(sema(cu).typeSymbol(typeBinding(c1))) + assertThat(SemanticTestSupport.type(c1).symbol()) .as("of top-level class") - .hasOwner(sema(cu).packageSymbol(typeBinding(c1).getPackage())); + .hasOwner(SemanticTestSupport.type(c1).symbol().owner()); - assertThat(sema(cu).typeSymbol(typeBinding(c2))) + assertThat(SemanticTestSupport.type(c2).symbol()) .as("of nested class") - .hasOwner(sema(cu).typeSymbol(typeBinding(c1))); + .hasOwner(SemanticTestSupport.type(c1).symbol()); - assertThat(sema(cu).typeSymbol(typeBinding(c3))) + assertThat(SemanticTestSupport.type(c3).symbol()) .as("of local class") - .hasOwner(sema(cu).methodSymbol(methodBinding(m))); + .hasOwner(SemanticTestSupport.method(m)); - assertThat(sema(cu).methodSymbol(methodBinding(m))) + assertThat(SemanticTestSupport.method(m)) .as("of method") - .hasOwner(sema(cu).typeSymbol(typeBinding(c1))); + .hasOwner(SemanticTestSupport.type(c1).symbol()); - assertThat(sema(cu).variableSymbol(variableBinding(f))) + assertThat(SemanticTestSupport.symbol(f)) .as("of field") - .hasOwner(sema(cu).typeSymbol(typeBinding(c1))); + .hasOwner(SemanticTestSupport.type(c1).symbol()); - assertThat(sema(cu).variableSymbol(variableBinding(p))) + assertThat(SemanticTestSupport.symbol(p)) .as("of method parameter") - .hasOwner(sema(cu).methodSymbol(methodBinding(m))); + .hasOwner(SemanticTestSupport.method(m)); - assertThat(sema(cu).typeSymbol(variableBinding(p).getType())) + assertThat((SemanticTestSupport.symbol(p).type()).symbol()) .as("of type int") .hasOwner(Symbol.ROOT_PACKAGE) .hasSameHashCodeAs(p.type().symbolType().symbol().hashCode()); - assertThat(sema(cu).packageSymbol(null)) + assertThat(SemanticTestSupport.type(c1).symbol().owner().owner()) .isEqualTo(Symbol.ROOT_PACKAGE); - JType uType = sema(cu).type(variableBinding(u).getType()); + Type uType = (SemanticTestSupport.symbol(u).type()); Symbol.TypeSymbol uTypeSymbol = uType.symbol(); assertThat(uType.isUnknown()).isTrue(); assertThat(uTypeSymbol.isUnknown()).isTrue(); @@ -167,13 +158,13 @@ void owner_local_record() { ClassTreeImpl r = (ClassTreeImpl) m.block().body().get(0); VariableTreeImpl p = (VariableTreeImpl) r.recordComponents().get(0); - assertThat(sema(cu).variableSymbol(variableBinding(p))) + assertThat(SemanticTestSupport.symbol(p)) .as("of record component") - .hasOwner(sema(cu).typeSymbol(typeBinding(r))); + .hasOwner(SemanticTestSupport.type(r).symbol()); - assertThat(sema(cu).methodSymbol(methodBinding(m))) + assertThat(SemanticTestSupport.method(m)) .as("of method") - .hasOwner(sema(cu).typeSymbol(typeBinding(c1))); + .hasOwner(SemanticTestSupport.type(c1).symbol()); } @Test @@ -188,7 +179,7 @@ class C { var lambda = (LambdaExpressionTree) ((VariableTree) classTree.members().get(0)).initializer(); var i = (IdentifierTree) lambda.body(); Symbol owner = i.symbol().owner(); - assertTrue(owner instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()); + assertTrue(SemanticTestSupport.isLambda(owner)); } @Test @@ -207,7 +198,7 @@ void foo() { LambdaExpressionTree lambda = (LambdaExpressionTree) bindingInsideMethod.initializer(); VariableTree l = lambda.parameters().get(0); Symbol owner = l.symbol().owner(); - assertTrue(owner instanceof JMethodSymbol methodSymbol && methodSymbol.isLambda()); + assertTrue(SemanticTestSupport.isLambda(owner)); } @Test @@ -216,8 +207,8 @@ void primitive_type_hash_code() { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); VariableTreeImpl uField = (VariableTreeImpl) c.members().get(0); VariableTreeImpl vField = (VariableTreeImpl) c.members().get(1); - assertThat(sema(cu).typeSymbol(variableBinding(uField).getType())) - .hasSameHashCodeAs(sema(cu).typeSymbol(variableBinding(vField).getType())); + assertThat((SemanticTestSupport.symbol(uField).type()).symbol()) + .hasSameHashCodeAs((SemanticTestSupport.symbol(vField).type()).symbol()); } @Test @@ -230,29 +221,29 @@ void enclosingClass() { VariableTreeImpl p = (VariableTreeImpl) m.parameters().get(0); ClassTreeImpl c3 = (ClassTreeImpl) m.block().body().get(0); - assertThat(sema(cu).typeSymbol(typeBinding(c1))) + assertThat(SemanticTestSupport.type(c1).symbol()) .as("of top-level class") - .hasEnclosingClass(sema(cu).typeSymbol(typeBinding(c1))); + .hasEnclosingClass(SemanticTestSupport.type(c1).symbol()); - assertThat(sema(cu).typeSymbol(typeBinding(c2))) + assertThat(SemanticTestSupport.type(c2).symbol()) .as("of nested class") - .hasEnclosingClass(sema(cu).typeSymbol(typeBinding(c1))); + .hasEnclosingClass(SemanticTestSupport.type(c1).symbol()); - assertThat(sema(cu).typeSymbol(typeBinding(c3))) + assertThat(SemanticTestSupport.type(c3).symbol()) .as("of local class") - .hasEnclosingClass(sema(cu).typeSymbol(typeBinding(c1))); + .hasEnclosingClass(SemanticTestSupport.type(c1).symbol()); - assertThat(sema(cu).methodSymbol(methodBinding(m))) + assertThat(SemanticTestSupport.method(m)) .as("of method") - .hasEnclosingClass(sema(cu).typeSymbol(typeBinding(c1))); + .hasEnclosingClass(SemanticTestSupport.type(c1).symbol()); - assertThat(sema(cu).variableSymbol(variableBinding(f))) + assertThat(SemanticTestSupport.symbol(f)) .as("of field") - .hasEnclosingClass(sema(cu).typeSymbol(typeBinding(c1))); + .hasEnclosingClass(SemanticTestSupport.type(c1).symbol()); - assertThat(sema(cu).variableSymbol(variableBinding(p))) + assertThat(SemanticTestSupport.symbol(p)) .as("of method parameter") - .hasEnclosingClass(sema(cu).typeSymbol(typeBinding(c1))); + .hasEnclosingClass(SemanticTestSupport.type(c1).symbol()); } @Test @@ -263,13 +254,13 @@ void record_enclosingClass() { ClassTreeImpl c2 = (ClassTreeImpl) c1.members().get(0); VariableTreeImpl p = (VariableTreeImpl) c2.recordComponents().get(0); - assertThat(sema(cu).variableSymbol(variableBinding(f))) + assertThat(SemanticTestSupport.symbol(f)) .as("of field") - .hasEnclosingClass(sema(cu).typeSymbol(typeBinding(c1))); + .hasEnclosingClass(SemanticTestSupport.type(c1).symbol()); - assertThat(sema(cu).variableSymbol(variableBinding(p))) + assertThat(SemanticTestSupport.symbol(p)) .as("of method parameter") - .hasEnclosingClass(sema(cu).typeSymbol(typeBinding(c2))); + .hasEnclosingClass(SemanticTestSupport.type(c2).symbol()); } @Test @@ -296,16 +287,16 @@ private void variable_in_class_initializer(boolean isStatic) { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); BlockTreeImpl b = (BlockTreeImpl) c.members().get(1); VariableTreeImpl v = (VariableTreeImpl) b.body().get(0); - Symbol.TypeSymbol t = sema(cu).typeSymbol(typeBinding(c)); + Symbol.TypeSymbol t = SemanticTestSupport.type(c).symbol(); - JVariableSymbol variableSymbol = sema(cu).variableSymbol(variableBinding(v)); + Symbol.VariableSymbol variableSymbol = SemanticTestSupport.symbol(v); assertThat(variableSymbol).isSameAs(v.symbol()); JInitializerBlockSymbol initializerBlock = (JInitializerBlockSymbol) variableSymbol.owner(); if (isStatic) { - assertThat(initializerBlock).isSameAs(sema(cu).staticInitializerBlockSymbol((JTypeSymbol) c.symbol())); + assertThat(initializerBlock).isSameAs(SemanticTestSupport.initializer(c.symbol(), true)); } else { - assertThat(initializerBlock).isSameAs(sema(cu).initializerBlockSymbol((JTypeSymbol) c.symbol())); + assertThat(initializerBlock).isSameAs(SemanticTestSupport.initializer(c.symbol(), false)); } assertThat(variableSymbol).hasEnclosingClass(t); @@ -363,17 +354,17 @@ void type() { VariableTreeImpl field = (VariableTreeImpl) c.members().get(0); MethodTreeImpl method = (MethodTreeImpl) c.members().get(1); - assertThat(sema(cu).typeSymbol(typeBinding(c)).owner()) + assertThat(SemanticTestSupport.type(c).symbol().owner()) .isOfSameTypeAs(c.symbol().owner()) .isOfUnknownType(); - assertThat(sema(cu).typeSymbol(typeBinding(c))) - .isOfType(sema(cu).type(typeBinding(c))); + assertThat(SemanticTestSupport.type(c).symbol()) + .isOfType(SemanticTestSupport.type(c)); - assertThat(sema(cu).variableSymbol(variableBinding(field))) - .isOfType(sema(cu).type(variableBinding(field).getType())); + assertThat(SemanticTestSupport.symbol(field)) + .isOfType((SemanticTestSupport.symbol(field).type())); - assertThat(sema(cu).methodSymbol(methodBinding(method))).isOfUnknownType(); + assertThat(SemanticTestSupport.method(method)).isOfUnknownType(); } @Test @@ -403,8 +394,8 @@ void var_type_as_local_variable() { assertThat(variable.symbol()) .isOfType("java.util.ArrayList"); - assertThat(sema(cu).variableSymbol(variableBinding(variable))) - .isOfType(sema(cu).type(variableBinding(variable).getType())); + assertThat(SemanticTestSupport.symbol(variable)) + .isOfType((SemanticTestSupport.symbol(variable).type())); } @Test @@ -438,14 +429,12 @@ void test_with_type_annotation() { @Test void test_with_type_null() { - ASTParser astParser = ASTParser.newParser(AST.getJLSLatest()); - astParser.setSource("class C { void m(String p) { } }".toCharArray()); - CompilationUnit cu = (CompilationUnit) astParser.createAST(null); - JSema jSema = new JSema(cu.getAST()); - IVariableBinding mock = mock(IVariableBinding.class); - when(mock.getKind()).thenReturn(IBinding.VARIABLE); - JVariableSymbol jVariableSymbol = new JVariableSymbol(jSema, mock); - assertThat(jVariableSymbol.metadata()).isNotNull(); + var cu = test("class C { void m(String p) { } }"); + var variable = mock(com.intellij.psi.PsiVariable.class); + when(variable.getType()).thenReturn(null); + when(variable.getAnnotations()).thenReturn(new com.intellij.psi.PsiAnnotation[0]); + var symbol = new JVariableSymbol((JSema) cu.sema, variable, com.intellij.psi.PsiSubstitutor.EMPTY, "broken"); + assertThat(symbol.metadata()).isNotNull(); } @Nested @@ -466,30 +455,30 @@ void parse() { @Test void isPackageSymbol() { - JTypeSymbol c1Symbol = sema(cu).typeSymbol(typeBinding(c1)); + Symbol.TypeSymbol c1Symbol = SemanticTestSupport.type(c1).symbol(); assertThat(c1Symbol.isPackageSymbol()).isFalse(); assertThat(c1Symbol.owner().isPackageSymbol()).isTrue(); } @Test void isTypeSymbol() { - assertThat(sema(cu).typeSymbol(typeBinding(c1)).isTypeSymbol()).isTrue(); - assertThat(sema(cu).methodSymbol(methodBinding(foo)).isTypeSymbol()).isFalse(); - assertThat(sema(cu).variableSymbol(variableBinding(f)).isTypeSymbol()).isFalse(); + assertThat(SemanticTestSupport.type(c1).symbol().isTypeSymbol()).isTrue(); + assertThat(SemanticTestSupport.method(foo).isTypeSymbol()).isFalse(); + assertThat(SemanticTestSupport.symbol(f).isTypeSymbol()).isFalse(); } @Test void isMethodSymbol() { - assertThat(sema(cu).typeSymbol(typeBinding(c1)).isMethodSymbol()).isFalse(); - assertThat(sema(cu).methodSymbol(methodBinding(foo)).isMethodSymbol()).isTrue(); - assertThat(sema(cu).variableSymbol(variableBinding(f)).isMethodSymbol()).isFalse(); + assertThat(SemanticTestSupport.type(c1).symbol().isMethodSymbol()).isFalse(); + assertThat(SemanticTestSupport.method(foo).isMethodSymbol()).isTrue(); + assertThat(SemanticTestSupport.symbol(f).isMethodSymbol()).isFalse(); } @Test void isVariableSymbol() { - assertThat(sema(cu).typeSymbol(typeBinding(c1)).isVariableSymbol()).isFalse(); - assertThat(sema(cu).methodSymbol(methodBinding(foo)).isVariableSymbol()).isFalse(); - assertThat(sema(cu).variableSymbol(variableBinding(f)).isVariableSymbol()).isTrue(); + assertThat(SemanticTestSupport.type(c1).symbol().isVariableSymbol()).isFalse(); + assertThat(SemanticTestSupport.method(foo).isVariableSymbol()).isFalse(); + assertThat(SemanticTestSupport.symbol(f).isVariableSymbol()).isTrue(); } } @@ -591,10 +580,10 @@ void isVolatile() { + " int b;" + "}"); - JVariableSymbol a = variable(cu, 0); + Symbol.VariableSymbol a = variable(cu, 0); assertThat(a.isVolatile()).isTrue(); - JVariableSymbol b = variable(cu, 1); + Symbol.VariableSymbol b = variable(cu, 1); assertThat(b.isVolatile()).isFalse(); } @@ -604,8 +593,8 @@ void isInterface() { "interface I1 { } " + "class C1 { }"); - assertThat(sema(cu).typeSymbol(typeBinding(((ClassTreeImpl) cu.types().get(0)))).isInterface()).isTrue(); - assertThat(sema(cu).typeSymbol(typeBinding(((ClassTreeImpl) cu.types().get(1)))).isInterface()).isFalse(); + assertThat(SemanticTestSupport.type(((ClassTreeImpl) cu.types().get(0))).symbol().isInterface()).isTrue(); + assertThat(SemanticTestSupport.type(((ClassTreeImpl) cu.types().get(1))).symbol().isInterface()).isFalse(); } @Test @@ -613,39 +602,39 @@ void isEnum() { JavaTree.CompilationUnitTreeImpl cu = test("class C1 { int a; void foo() { }} enum E1 { ACONST; }"); ClassTreeImpl c1 = (ClassTreeImpl) cu.types().get(0); - JTypeSymbol c1Symbol = sema(cu).typeSymbol(typeBinding(c1)); + Symbol.TypeSymbol c1Symbol = SemanticTestSupport.type(c1).symbol(); assertThat(c1Symbol.isEnum()).isFalse(); - JVariableSymbol a = sema(cu).variableSymbol(variableBinding(((VariableTreeImpl) c1.members().get(0)))); + Symbol.VariableSymbol a = SemanticTestSupport.symbol(((VariableTreeImpl) c1.members().get(0))); assertThat(a.isEnum()).isFalse(); - JMethodSymbol foo = sema(cu).methodSymbol(methodBinding(((MethodTreeImpl) c1.members().get(1)))); + Symbol.MethodSymbol foo = SemanticTestSupport.method(((MethodTreeImpl) c1.members().get(1))); assertThat(foo.isEnum()).isFalse(); ClassTreeImpl e1 = (ClassTreeImpl) cu.types().get(1); - JTypeSymbol e1Symbol = sema(cu).typeSymbol(typeBinding(e1)); + Symbol.TypeSymbol e1Symbol = SemanticTestSupport.type(e1).symbol(); assertThat(e1Symbol.isEnum()).isTrue(); - JVariableSymbol aconst = sema(cu).variableSymbol(variableBinding(((EnumConstantTreeImpl) e1.members().get(0)))); + Symbol.VariableSymbol aconst = SemanticTestSupport.symbol(((EnumConstantTreeImpl) e1.members().get(0))); assertThat(aconst.isEnum()).isTrue(); } - private JMethodSymbol foo(JavaTree.CompilationUnitTreeImpl cu) { + private Symbol.MethodSymbol foo(JavaTree.CompilationUnitTreeImpl cu) { return method(cu, 0); } - private JMethodSymbol bar(JavaTree.CompilationUnitTreeImpl cu) { + private Symbol.MethodSymbol bar(JavaTree.CompilationUnitTreeImpl cu) { return method(cu, 1); } - private JMethodSymbol method(JavaTree.CompilationUnitTreeImpl cu, int memberIndex) { + private Symbol.MethodSymbol method(JavaTree.CompilationUnitTreeImpl cu, int memberIndex) { ClassTreeImpl c1 = (ClassTreeImpl) cu.types().get(0); - return sema(cu).methodSymbol(methodBinding(((MethodTreeImpl) c1.members().get(memberIndex)))); + return SemanticTestSupport.method(((MethodTreeImpl) c1.members().get(memberIndex))); } - private JVariableSymbol variable(JavaTree.CompilationUnitTreeImpl cu, int memberIndex) { + private Symbol.VariableSymbol variable(JavaTree.CompilationUnitTreeImpl cu, int memberIndex) { ClassTreeImpl c1 = (ClassTreeImpl) cu.types().get(0); - return sema(cu).variableSymbol(variableBinding(((VariableTreeImpl) c1.members().get(memberIndex)))); + return SemanticTestSupport.symbol(((VariableTreeImpl) c1.members().get(memberIndex))); } } @@ -758,10 +747,10 @@ int f(int i) { """); ClassTree cClassTree = (ClassTree) cu.types().get(0); - JSymbol cSymbol = (JSymbol) cClassTree.symbol(); + Symbol cSymbol = cClassTree.symbol(); MethodTree f = (MethodTree) cClassTree.members().get(0); - JSymbol fSymbol = (JSymbol) f.symbol(); + Symbol fSymbol = f.symbol(); assertNotEquals(fSymbol, cSymbol); // Symmetric case diff --git a/java-frontend/src/test/java/org/sonar/java/model/JTypeSymbolTest.java b/java-frontend/src/test/java/org/sonar/java/model/JTypeSymbolTest.java index 9c6ea3865d1..c14b79c6fc5 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JTypeSymbolTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JTypeSymbolTest.java @@ -16,23 +16,18 @@ */ package org.sonar.java.model; -import java.util.Objects; -import org.eclipse.jdt.core.dom.ITypeBinding; import org.junit.jupiter.api.Test; import org.sonar.java.model.declaration.ClassTreeImpl; import org.sonar.java.model.declaration.MethodTreeImpl; import org.sonar.java.model.declaration.VariableTreeImpl; import org.sonar.java.test.TestResourceScope; +import org.sonar.plugins.java.api.semantic.Symbol; import org.sonar.plugins.java.api.semantic.Type; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertAll; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; -import static org.sonar.java.model.EcjTestSupport.methodBinding; -import static org.sonar.java.model.EcjTestSupport.sema; -import static org.sonar.java.model.EcjTestSupport.typeBinding; -import static org.sonar.java.model.EcjTestSupport.variableBinding; @TestResourceScope.Scoped class JTypeSymbolTest { @@ -56,12 +51,11 @@ void superClass() { @Test void testSuperClassWhenSemanticCanNotResolveObjectType() { var cu = test("interface I{}"); - var i = (ClassTreeImpl) cu.types().get(0); - - JSema sematicThatCanNotResolveObjectType = spy(sema(cu)); - when(sematicThatCanNotResolveObjectType.resolveType("java.lang.Object")).thenReturn(null); - var typeSymbol = new JTypeSymbol(sematicThatCanNotResolveObjectType, typeBinding(i)); - assertThat(typeSymbol.superClass()).isSameAs(Type.UNKNOWN); + var original = (JType) ((ClassTreeImpl) cu.types().getFirst()).symbol().type(); + var broken = spy((JSema) cu.sema); + when(broken.getClassType("java.lang.Object")).thenReturn(Type.UNKNOWN); + var type = new JType(broken, original.psi, original.key); + assertThat(new JTypeSymbol(broken, type, original.key).superClass()).isSameAs(Type.UNKNOWN); } @Test @@ -80,38 +74,43 @@ void memberSymbols() { VariableTreeImpl f = (VariableTreeImpl) c.members().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(1); ClassTreeImpl n = (ClassTreeImpl) c.members().get(2); - assertThat(sema(cu).typeSymbol(typeBinding(c)).memberSymbols()) + assertThat(SemanticTestSupport.type(c).symbol().memberSymbols()) .containsOnly( - sema(cu).variableSymbol(variableBinding(f)), - sema(cu).methodSymbol(methodBinding(m)), - sema(cu).typeSymbol(typeBinding(n)) + SemanticTestSupport.symbol(f), + SemanticTestSupport.method(m), + SemanticTestSupport.type(n).symbol() ); } @Test void superTypesTest(){ JavaTree.CompilationUnitTreeImpl cu = test("interface I { } class C implements I { } class C2 extends C { }"); - ITypeBinding javaLangObject = Objects.requireNonNull(sema(cu).resolveType("java.lang.Object")); - assertThat(sema(cu).typeSymbol(javaLangObject).superTypes()).isEmpty(); + Type javaLangObject = cu.sema.getClassType("java.lang.Object"); + assertThat(javaLangObject.symbol().superTypes()).isEmpty(); ClassTreeImpl interfaceI = (ClassTreeImpl) cu.types().get(0); - JTypeSymbol interfaceITypeSymbol = sema(cu).typeSymbol(typeBinding(interfaceI)); + Symbol.TypeSymbol interfaceITypeSymbol = SemanticTestSupport.type(interfaceI).symbol(); assertThat(interfaceITypeSymbol.superTypes()).isEmpty(); assertThat(interfaceITypeSymbol.superTypes()).isEmpty(); // repeat call to cover cache ClassTreeImpl classC = (ClassTreeImpl) cu.types().get(1); - JTypeSymbol classCTypeSymbol = sema(cu).typeSymbol(typeBinding(classC)); - assertThat(classCTypeSymbol.superTypes()).containsExactly(interfaceITypeSymbol.type(), sema(cu).type(javaLangObject)); + Symbol.TypeSymbol classCTypeSymbol = SemanticTestSupport.type(classC).symbol(); + assertThat(classCTypeSymbol.superTypes()).containsExactly(interfaceITypeSymbol.type(), javaLangObject); ClassTreeImpl classC2 = (ClassTreeImpl) cu.types().get(2); - JTypeSymbol classC2TypeSymbol = sema(cu).typeSymbol(typeBinding(classC2)); - assertThat(classC2TypeSymbol.superTypes()).containsExactly(classCTypeSymbol.type() ,interfaceITypeSymbol.type(), sema(cu).type(javaLangObject)); + Symbol.TypeSymbol classC2TypeSymbol = SemanticTestSupport.type(classC2).symbol(); + assertThat(classC2TypeSymbol.superTypes()).containsExactly(classCTypeSymbol.type(), interfaceITypeSymbol.type(), javaLangObject); + } - ITypeBinding brokenTypeBinding = spy(typeBinding(classC2)); - when(brokenTypeBinding.isRecovered()).thenReturn(true); - JTypeSymbol brokenTypeSymbol = new JTypeSymbol(sema(cu), brokenTypeBinding); - assertThat(brokenTypeSymbol.superTypes()).isEmpty(); + @Test + void recovered_super_types() { + var cu = test("interface I { } class C implements I { } class C2 extends C { }"); + var original = (JType) ((ClassTreeImpl) cu.types().get(2)).symbol().type(); + var broken = spy((com.intellij.psi.PsiClassType) original.psi); + when(broken.resolve()).thenReturn(null); + var type = new JType((JSema) cu.sema, broken, original.key); + assertThat(new JTypeSymbol((JSema) cu.sema, type, original.key).superTypes()).isEmpty(); } @Test @@ -119,37 +118,35 @@ void outermostClassTest() { JavaTree.CompilationUnitTreeImpl cu = test("class C { class N {} }"); ClassTreeImpl outerClass = (ClassTreeImpl) cu.types().get(0); ClassTreeImpl innerClass = (ClassTreeImpl) outerClass.members().get(0); - JTypeSymbol innerClassSymbol = sema(cu).typeSymbol(typeBinding(innerClass)); - JTypeSymbol outerClassSymbol = sema(cu).typeSymbol(typeBinding(outerClass)); + Symbol.TypeSymbol innerClassSymbol = SemanticTestSupport.type(innerClass).symbol(); + Symbol.TypeSymbol outerClassSymbol = SemanticTestSupport.type(outerClass).symbol(); assertThat(innerClassSymbol.outermostClass()).isSameAs(outerClassSymbol); assertThat(innerClassSymbol.outermostClass()).isSameAs(outerClassSymbol); } @Test void isAnnotationTest(){ - JTypeSymbol annotationSymbol = getJTypeSymbolFromClassText("@interface A { }", true); + Symbol.TypeSymbol annotationSymbol = getJTypeSymbolFromClassText("@interface A { }", true); assertThat(annotationSymbol.isAnnotation()).isFalse(); annotationSymbol = getJTypeSymbolFromClassText("@interface A { }", false); assertThat(annotationSymbol.isAnnotation()).isTrue(); - JTypeSymbol classSymbol = getJTypeSymbolFromClassText("class C { }", false); + Symbol.TypeSymbol classSymbol = getJTypeSymbolFromClassText("class C { }", false); assertThat(classSymbol.isAnnotation()).isFalse(); } @Test void isEffectivelyFinalTest(){ - JTypeSymbol classSymbol = getJTypeSymbolFromClassText("class C { }", false); - assertThat(classSymbol.superSymbol.isEffectivelyFinal()).isFalse(); + var classSymbol = getJTypeSymbolFromClassText("class C { }", false); + assertThat(((Symbol.VariableSymbol) SemanticTestSupport.specialField(classSymbol.type(), true)).isEffectivelyFinal()).isFalse(); } - private static JTypeSymbol getJTypeSymbolFromClassText(String classText, boolean isUnknown){ + private static Symbol.TypeSymbol getJTypeSymbolFromClassText(String classText, boolean isUnknown){ JavaTree.CompilationUnitTreeImpl cu = test(classText); ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); - if(isUnknown){ - ITypeBinding brokenTypeBinding = spy(typeBinding(c)); - when(brokenTypeBinding.isRecovered()).thenReturn(true); - return new JTypeSymbol(sema(cu), brokenTypeBinding); + if (isUnknown) { + return Symbol.TypeSymbol.UNKNOWN_TYPE; } - return new JTypeSymbol(sema(cu), typeBinding(c)); + return c.symbol(); } private static JavaTree.CompilationUnitTreeImpl test(String source) { diff --git a/java-frontend/src/test/java/org/sonar/java/model/JTypeTest.java b/java-frontend/src/test/java/org/sonar/java/model/JTypeTest.java index 979f2fc0802..b51ca340362 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JTypeTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JTypeTest.java @@ -18,7 +18,6 @@ import java.util.Objects; import java.util.stream.Stream; -import org.eclipse.jdt.core.dom.ITypeBinding; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -41,8 +40,6 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; -import static org.sonar.java.model.EcjTestSupport.sema; -import static org.sonar.java.model.EcjTestSupport.typeBinding; import static org.sonar.java.model.assertions.TypeAssert.assertThat; @TestResourceScope.Scoped @@ -97,7 +94,7 @@ void isParametrizedType() { ExpressionStatementTreeImpl s = (ExpressionStatementTreeImpl) Objects.requireNonNull(m.block()).body().get(0); AbstractTypedTree e = Objects.requireNonNull((AbstractTypedTree) s.expression()); - assertThat(sema(cu).type(typeBinding(e)).isParameterized()) + assertThat(SemanticTestSupport.type(e).isParameterized()) .isEqualTo(e.symbolType().isParameterized()) .isTrue(); } @@ -110,11 +107,11 @@ void typeArguments() { ExpressionStatementTreeImpl s = (ExpressionStatementTreeImpl) Objects.requireNonNull(m.block()).body().get(0); AbstractTypedTree e = Objects.requireNonNull((AbstractTypedTree) s.expression()); - assertThat(sema(cu).type(typeBinding(e)).typeArguments()) + assertThat(SemanticTestSupport.type(e).typeArguments()) .hasToString(e.symbolType().typeArguments().toString()) .hasToString("[Integer, String]"); - assertThat(sema(cu).type(typeBinding(c)).typeArguments()) + assertThat(SemanticTestSupport.type(c).typeArguments()) .isEqualTo(c.symbol().type().typeArguments()) .isEmpty(); } @@ -168,27 +165,20 @@ void non_primitive_wrapper_tpe_has_no_primitive_wrapper() { @Test void primitiveWrapperType_returns_null_when_semantic_cannot_resolve_wrapper_type() { - // Sema that can resolve primitives, but fails to resolve wrapper types, which can happen when the classpath is not correctly set up - var brokenSema = spy(sema); - when(brokenSema.resolveType("java.lang.Byte")).thenReturn(null); - - var primitiveBinding = sema.resolveType("byte"); - var primitiveType = new JType(brokenSema, primitiveBinding); - - assertThat(primitiveType.primitiveWrapperType()).isNull(); + var original = (JSema) test("class C {}").sema; + var broken = spy(original); + when(broken.getClassType("java.lang.Byte")).thenReturn(Type.UNKNOWN); + var primitive = (JType) original.getClassType("byte"); + assertThat(new JType(broken, primitive.psi, primitive.key).primitiveWrapperType()).isNull(); } @Test void primitiveType_returns_null_when_semantic_cannot_resolve_primitive_type() { - // Sema that can resolve wrapper types, but fails to resolve a primitive, this should never happen in practice, - // but we want to make sure it doesn't throw an exception and returns null instead - var brokenSema = spy(sema); - when(brokenSema.resolveType("byte")).thenReturn(null); - - var wrapperBinding = sema.resolveType("java.lang.Byte"); - var wrapperType = new JType(brokenSema, wrapperBinding); - - assertThat(wrapperType.primitiveType()).isNull(); + var original = (JSema) test("class C {}").sema; + var broken = spy(original); + when(broken.getClassType("byte")).thenReturn(Type.UNKNOWN); + var wrapper = (JType) original.getClassType("java.lang.Byte"); + assertThat(new JType(broken, wrapper.psi, wrapper.key).primitiveType()).isNull(); } @Test @@ -237,11 +227,11 @@ void name_of_parameterized_type() { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); AbstractTypedTree e = Objects.requireNonNull((AbstractTypedTree) m.returnType()); - JType parameterizedType = sema(cu).type(Objects.requireNonNull(typeBinding(e))); + Type parameterizedType = Objects.requireNonNull(SemanticTestSupport.type(e)); assertThat(parameterizedType) .hasSameNameAs(e.symbolType()) - .hasSameNameAs(sema(cu).typeSymbol(typeBinding(e)).type()) + .hasSameNameAs(SemanticTestSupport.type(e).symbol().type()) .is("java.util.List") .hasName("List"); } @@ -252,10 +242,10 @@ void name_of_type_variable() { ClassTreeImpl c = (ClassTreeImpl) cu.types().get(0); MethodTreeImpl m = (MethodTreeImpl) c.members().get(0); AbstractTypedTree e = Objects.requireNonNull((AbstractTypedTree) m.returnType()); - JType typeVariable = sema(cu).type(Objects.requireNonNull(typeBinding(e))); + Type typeVariable = Objects.requireNonNull(SemanticTestSupport.type(e)); assertThat(typeVariable) .hasSameNameAs(e.symbolType()) - .hasSameNameAs(sema(cu).typeSymbol(typeBinding(e)).type()) + .hasSameNameAs(SemanticTestSupport.type(e).symbol().type()) .hasName("T") .is(e.symbolType().fullyQualifiedName()) .is("T"); @@ -263,9 +253,9 @@ void name_of_type_variable() { @Test void symbol() { - ITypeBinding typeBinding = Objects.requireNonNull(sema.resolveType("java.lang.Object")); - assertThat(sema.type(typeBinding).symbol()) - .isSameAs(sema.typeSymbol(typeBinding)); + Type typeBinding = sema.getClassType("java.lang.Object"); + assertThat(typeBinding.symbol()) + .isSameAs(sema.getClassType("java.lang.Object").symbol()); } @Test @@ -310,10 +300,10 @@ void null_type() { AbstractTypedTree primitive = (AbstractTypedTree) m.parameters().get(0).type(); AbstractTypedTree array = (AbstractTypedTree) m.parameters().get(1).type(); - JType nullType = sema(cu).type(Objects.requireNonNull(typeBinding(e))); - JType classType = sema(cu).type(Objects.requireNonNull(typeBinding(c))); - JType primitiveType = sema(cu).type(Objects.requireNonNull(typeBinding(primitive))); - JType arrayType = sema(cu).type(Objects.requireNonNull(typeBinding(array))); + Type nullType = Objects.requireNonNull(SemanticTestSupport.type(e)); + Type classType = Objects.requireNonNull(SemanticTestSupport.type(c)); + Type primitiveType = Objects.requireNonNull(SemanticTestSupport.type(primitive)); + Type arrayType = Objects.requireNonNull(SemanticTestSupport.type(array)); assertThat(nullType) .hasSameNameAs(e.symbolType()) @@ -327,18 +317,13 @@ void null_type() { @Test void is_subtype_of_should_not_throw_NPE() { - Type objectType = type("java.lang.Object"); - ITypeBinding brokenStringBinding = spy(Objects.requireNonNull(sema.resolveType("java.lang.String"))); - // simulate the NullPointerException described in SONARJAVA-4390 - when(brokenStringBinding.isSubTypeCompatible(any())) - .thenThrow(new NullPointerException("test NPE")); - - JType stringType = new JType(sema, brokenStringBinding); - // should catch the NullPointerException - assertThat(stringType.isSubtypeOf(objectType)).isFalse(); - - assertThat(logTester.logs(Level.DEBUG)) - .containsExactly("NullPointerException while resolving isSubTypeCompatible()"); + var original = (JSema) test("class C {}").sema; + var string = (JType) original.getClassType("java.lang.String"); + var broken = spy((com.intellij.psi.PsiClassType) string.psi); + when(broken.resolveGenerics()).thenThrow(new NullPointerException("test NPE")); + var stringType = new JType(original, broken, string.key); + assertThat(stringType.isSubtypeOf(original.getClassType("java.lang.Object"))).isFalse(); + assertThat(logTester.logs(Level.DEBUG)).containsExactly("NullPointerException while resolving isSubTypeCompatible()"); } @Test @@ -350,9 +335,9 @@ void wildcard() { JavaTree.WildcardTreeImpl w1 = (JavaTree.WildcardTreeImpl) p.typeArguments().get(0); JavaTree.WildcardTreeImpl w2 = (JavaTree.WildcardTreeImpl) p.typeArguments().get(1); JavaTree.WildcardTreeImpl w3 = (JavaTree.WildcardTreeImpl) p.typeArguments().get(2); - JType wildcardType1 = sema(cu).type(Objects.requireNonNull(typeBinding(w1))); - JType wildcardType2 = sema(cu).type(Objects.requireNonNull(typeBinding(w2))); - JType wildcardType3 = sema(cu).type(Objects.requireNonNull(typeBinding(w3))); + Type wildcardType1 = Objects.requireNonNull(SemanticTestSupport.type(w1)); + Type wildcardType2 = Objects.requireNonNull(SemanticTestSupport.type(w2)); + Type wildcardType3 = Objects.requireNonNull(SemanticTestSupport.type(w3)); assertThat(wildcardType1) .isEqualTo(wildcardType2) @@ -367,13 +352,13 @@ private Type type(String name) { return fixture.type(name); } - private JSema sema; + private org.sonar.plugins.java.api.semantic.Sema sema; private SemanticFixture fixture; @BeforeEach void setup() { fixture = SemanticFixture.scoped("", java.util.List.of()); - sema = sema(fixture.tree()); + sema = fixture.tree().sema; } } diff --git a/java-frontend/src/test/java/org/sonar/java/model/JUtilsTest.java b/java-frontend/src/test/java/org/sonar/java/model/JUtilsTest.java index 0b73a544754..206ca3ea1c4 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JUtilsTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JUtilsTest.java @@ -42,16 +42,12 @@ import static org.mockito.Mockito.CALLS_REAL_METHODS; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -import static org.sonar.java.model.EcjTestSupport.methodBinding; -import static org.sonar.java.model.EcjTestSupport.sema; -import static org.sonar.java.model.EcjTestSupport.typeBinding; -import static org.sonar.java.model.EcjTestSupport.variableBinding; @TestResourceScope.Scoped class JUtilsTest { - static final JSema SEMA = sema(test("")); - private static final Type OBJECT_TYPE = SEMA.type(SEMA.resolveType("java.lang.Object")); + final org.sonar.plugins.java.api.semantic.Sema SEMA = test("").sema; + private final Type OBJECT_TYPE = SEMA.getClassType("java.lang.Object"); @Test void semantic_helpers_use_the_existing_api_interfaces() { @@ -74,7 +70,7 @@ void semantic_helpers_use_the_existing_api_interfaces() { class PrimitiveType { @Test void java_lang_Byte() { - Type wrapperType = SEMA.type(SEMA.resolveType("java.lang.Byte")); + Type wrapperType = SEMA.getClassType("java.lang.Byte"); Type primitiveType = wrapperType.primitiveType(); assertThat(primitiveType).isNotNull(); @@ -91,7 +87,7 @@ void object_is_not_a_primitive_type() { class PrimitiveWrapperType { @Test void java_lang_Byte() { - Type primitiveType = SEMA.type(SEMA.resolveType("byte")); + Type primitiveType = SEMA.getClassType("byte"); Type wrapperType = primitiveType.primitiveWrapperType(); assertThat(wrapperType).isNotNull(); @@ -106,7 +102,7 @@ void object_is_not_a_primitive_wrapper_type() { @Nested class IsPrimitiveWrapper { - private final Type primitiveType = SEMA.type(SEMA.resolveType("byte")); + private final Type primitiveType = SEMA.getClassType("byte"); @Test void wrapper() { @@ -123,7 +119,7 @@ void not_a_wrapper() { @Test void not_a_class() { - Type objectArrayType = SEMA.type(SEMA.resolveType("java.lang.Object[]")); + Type objectArrayType = SEMA.getClassType("java.lang.Object[]"); assertThat(objectArrayType.isPrimitiveWrapper()).isFalse(); } } @@ -132,7 +128,7 @@ void not_a_class() { class WrapTypeIfPrimitiveTest { @Test void prim_to_wrapped() { - Type primitiveType = SEMA.type(SEMA.resolveType("byte")); + Type primitiveType = SEMA.getClassType("byte"); Type wrappedType = JUtils.wrapTypeIfPrimitive(primitiveType); assertThat(wrappedType).isNotNull(); assertThat(wrappedType.isPrimitive()).isFalse(); @@ -141,7 +137,7 @@ void prim_to_wrapped() { @Test void already_wrapped() { - Type boxedType = SEMA.type(SEMA.resolveType("java.lang.Byte")); + Type boxedType = SEMA.getClassType("java.lang.Byte"); Type wrappedType = JUtils.wrapTypeIfPrimitive(boxedType); assertThat(wrappedType).isNotNull(); assertThat(wrappedType.isPrimitive()).isFalse(); @@ -150,7 +146,7 @@ void already_wrapped() { @Test void unrelated() { - Type otherType = SEMA.type(SEMA.resolveType("java.lang.Object")); + Type otherType = SEMA.getClassType("java.lang.Object"); Type wrappedType = JUtils.wrapTypeIfPrimitive(otherType); assertThat(wrappedType).isNotNull(); assertThat(wrappedType.isPrimitive()).isFalse(); @@ -167,14 +163,14 @@ class IsNullType { void nullType() { ReturnStatementTreeImpl s = (ReturnStatementTreeImpl) m1.block().body().get(0); AbstractTypedTree e = (AbstractTypedTree) s.expression(); - assertThat(sema(cu).type(typeBinding(e)).isNullType()) + assertThat(SemanticTestSupport.type(e).isNullType()) .isEqualTo(e.symbolType().isNullType()) .isTrue(); } @Test void a_non_null_type_is_not_null_type() { - assertThat(sema(cu).type(methodBinding(m1).getReturnType()).isNullType()) + assertThat((SemanticTestSupport.method(m1).returnType().type()).isNullType()) .isEqualTo(m1.returnType().symbolType().isNullType()) .isFalse(); } @@ -182,7 +178,7 @@ void a_non_null_type_is_not_null_type() { @Test void unresolved_type_is_not_null_type() { MethodTreeImpl m2 = nthMethod(c, 1); - assertThat(sema(cu).type(methodBinding(m2).getReturnType()).isNullType()) + assertThat((SemanticTestSupport.method(m2).returnType().type()).isNullType()) .isEqualTo(m2.returnType().symbolType().isNullType()) .isFalse(); } @@ -205,14 +201,14 @@ class C { @Test void intersection_type() { TypeCastExpressionTreeImpl e = (TypeCastExpressionTreeImpl) f.initializer(); - assertThat(JUtils.isIntersectionType(sema(cu).type(typeBinding(e)))) + assertThat(JUtils.isIntersectionType(SemanticTestSupport.type(e))) .isEqualTo(JUtils.isIntersectionType(e.symbolType())) .isTrue(); } @Test void non_intersection_type() { - assertThat(JUtils.isIntersectionType(sema(cu).type(variableBinding(f).getType()))) + assertThat(JUtils.isIntersectionType((SemanticTestSupport.symbol(f).type()))) .isEqualTo(JUtils.isIntersectionType(f.symbol().type())) .isFalse(); } @@ -220,7 +216,7 @@ void non_intersection_type() { @Test void unresolved_type_is_not_an_intersection_type() { VariableTreeImpl u = nthField(c, 1); - assertThat(JUtils.isIntersectionType(sema(cu).type(variableBinding(u).getType()))) + assertThat(JUtils.isIntersectionType((SemanticTestSupport.symbol(u).type()))) .isEqualTo(JUtils.isIntersectionType(u.symbol().type())) .isFalse(); } @@ -234,7 +230,7 @@ class IsTypeVar { @Test void type_var() { VariableTreeImpl t = firstField(c); - assertThat(sema(cu).type(variableBinding(t).getType()).isTypeVar()) + assertThat((SemanticTestSupport.symbol(t).type()).isTypeVar()) .isEqualTo(t.symbol().type().isTypeVar()) .isTrue(); } @@ -247,7 +243,7 @@ void simple_type_is_not_a_type_var() { @Test void unresolved_type_is_not_a_type_var() { VariableTreeImpl u = nthField(c, 1); - assertThat(sema(cu).type(variableBinding(u).getType()).isTypeVar()) + assertThat((SemanticTestSupport.symbol(u).type()).isTypeVar()) .isEqualTo(u.symbol().type().isTypeVar()) .isFalse(); } @@ -411,22 +407,22 @@ void constantValue() { JavaTree.CompilationUnitTreeImpl specificCu = test("interface I { short SHORT = 42; char CHAR = 42; byte BYTE = 42; boolean BOOLEAN = false; }"); ClassTreeImpl specificC = firstClass(specificCu); - Symbol.VariableSymbol shortConstant = sema(specificCu).variableSymbol(variableBinding(firstField(specificC))); + Symbol.VariableSymbol shortConstant = SemanticTestSupport.symbol(firstField(specificC)); assertThat(shortConstant.constantValue().orElseThrow(AssertionError::new)) .isInstanceOf(Integer.class) .isEqualTo(42); - Symbol.VariableSymbol charConstant = sema(specificCu).variableSymbol(variableBinding(nthField(specificC, 1))); + Symbol.VariableSymbol charConstant = SemanticTestSupport.symbol(nthField(specificC, 1)); assertThat(charConstant.constantValue().orElseThrow(AssertionError::new)) .isInstanceOf(Integer.class) .isEqualTo(42); - Symbol.VariableSymbol byteConstant = sema(specificCu).variableSymbol(variableBinding(nthField(specificC, 2))); + Symbol.VariableSymbol byteConstant = SemanticTestSupport.symbol(nthField(specificC, 2)); assertThat(byteConstant.constantValue().orElseThrow(AssertionError::new)) .isInstanceOf(Integer.class) .isEqualTo(42); - Symbol.VariableSymbol booleanConstant = sema(specificCu).variableSymbol(variableBinding(nthField(specificC, 3))); + Symbol.VariableSymbol booleanConstant = SemanticTestSupport.symbol(nthField(specificC, 3)); assertThat(booleanConstant.constantValue().orElseThrow(AssertionError::new)) .isInstanceOf(Boolean.class) .isEqualTo(Boolean.FALSE); @@ -732,13 +728,13 @@ void isParametrizedMethod() { ExpressionStatementTreeImpl s = (ExpressionStatementTreeImpl) m.block().body().get(0); MethodInvocationTreeImpl methodInvocation = (MethodInvocationTreeImpl) s.expression(); - assertThat(sema(cu).methodSymbol(methodBinding(m)).isParametrizedMethod()) + assertThat(SemanticTestSupport.method(m).isParametrizedMethod()) .isEqualTo(m.symbol().isParametrizedMethod()) - .isEqualTo(methodBinding(m).isGenericMethod()) + .isEqualTo(SemanticTestSupport.method(m).isParametrizedMethod()) .isTrue(); - assertThat(sema(cu).methodSymbol(methodBinding(methodInvocation)).isParametrizedMethod()) + assertThat(SemanticTestSupport.method(methodInvocation).isParametrizedMethod()) .isEqualTo(methodInvocation.methodSymbol().isParametrizedMethod()) - .isEqualTo(methodBinding(methodInvocation).isParameterizedMethod()) + .isEqualTo(SemanticTestSupport.method(methodInvocation).isParametrizedMethod()) .isTrue(); } diff --git a/java-frontend/src/test/java/org/sonar/java/model/JavaTreeModelTest.java b/java-frontend/src/test/java/org/sonar/java/model/JavaTreeModelTest.java index 926c7b3012d..4544405ae8c 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JavaTreeModelTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JavaTreeModelTest.java @@ -249,7 +249,6 @@ void null_literal() { * (Second Preview in Java 14) https://openjdk.java.net/jeps/368 * https://openjdk.java.net/jeps/378 * - * @see org.eclipse.jdt.core.dom.TextBlock */ @Test void expression_text_block() { @@ -265,8 +264,6 @@ void expression_text_block() { /** * Switch Expressions http://openjdk.java.net/jeps/361 * - * @see org.eclipse.jdt.core.dom.SwitchExpression - * @see org.eclipse.jdt.core.dom.YieldStatement */ @Test void expression_switch() { diff --git a/java-frontend/src/test/java/org/sonar/java/model/KeywordSuperTest.java b/java-frontend/src/test/java/org/sonar/java/model/KeywordSuperTest.java index 776bc2be775..9f79e940156 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/KeywordSuperTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/KeywordSuperTest.java @@ -24,8 +24,8 @@ import org.sonar.plugins.java.api.tree.VariableTree; import static org.assertj.core.api.Assertions.assertThat; -import static org.sonar.java.model.EcjTestSupport.clearSymbol; -import static org.sonar.java.model.EcjTestSupport.clearType; +import static org.sonar.java.model.SemanticTestSupport.clearSymbol; +import static org.sonar.java.model.SemanticTestSupport.clearType; @TestResourceScope.Scoped class KeywordSuperTest { diff --git a/java-frontend/src/test/java/org/sonar/java/model/KeywordThisTest.java b/java-frontend/src/test/java/org/sonar/java/model/KeywordThisTest.java index 8d634104562..9674c03f7ae 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/KeywordThisTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/KeywordThisTest.java @@ -24,8 +24,8 @@ import org.sonar.plugins.java.api.tree.VariableTree; import static org.assertj.core.api.Assertions.assertThat; -import static org.sonar.java.model.EcjTestSupport.clearSymbol; -import static org.sonar.java.model.EcjTestSupport.clearType; +import static org.sonar.java.model.SemanticTestSupport.clearSymbol; +import static org.sonar.java.model.SemanticTestSupport.clearType; @TestResourceScope.Scoped class KeywordThisTest { diff --git a/java-frontend/src/test/java/org/sonar/java/model/PsiFrontendBackendTest.java b/java-frontend/src/test/java/org/sonar/java/model/PsiFrontendBackendTest.java new file mode 100644 index 00000000000..df1ebcb1508 --- /dev/null +++ b/java-frontend/src/test/java/org/sonar/java/model/PsiFrontendBackendTest.java @@ -0,0 +1,249 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import com.intellij.openapi.application.ApplicationManager; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.BiConsumer; +import org.eclipse.core.runtime.OperationCanceledException; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import org.sonar.api.batch.fs.InputFile; +import org.sonar.java.AnalysisProgress; +import org.sonar.java.ProgressMonitor; +import org.sonar.plugins.java.api.tree.ClassTree; +import org.sonar.plugins.java.api.tree.VariableTree; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +class PsiFrontendBackendTest { + private static final FrontendConfiguration CONFIGURATION = FrontendConfiguration.from(JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, List.of(), false); + + @ParameterizedTest + @EnumSource(JParserConfig.Mode.class) + void normal_entry_points_use_selected_backend(JParserConfig.Mode mode) throws IOException { + var config = mode.create(JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, List.of()); + config.parse(List.of(input("A.java", "class A { String value; }")), () -> false, new AnalysisProgress(1), (file, result) -> { + var tree = tree(result); + assertThat(tree.sema instanceof JSema).isTrue(); + assertThat(tree.sema.getClassType("java.lang.String").is("java.lang.String")).isTrue(); + }); + try (var parsed = FrontendParser.parse(JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, List.of(), "A.java", "class A {}")) { + assertThat(parsed.tree().sema instanceof JSema).isTrue(); + } + } + + @Test + void batch_uses_decoded_snapshots_and_file_local_semantics() throws IOException { + var a = input("A.java", "package p; class A { B b; String text = \"é\"; }"); + var b = input("B.java", "package p; class B { String value; }"); + var callbacks = new ArrayList(); + var trees = new ArrayList(); + try (var session = new PsiFrontendBackend().open(CONFIGURATION)) { + var monitor = new ProgressMonitor(() -> false, new AnalysisProgress(2)); + try { + session.parseBatch(FrontendBatch.from(List.of(a, b)), monitor, (input, unit) -> { + try { + var tree = unit.convert(); + trees.add(tree); + callbacks.add(input.filename()); + assertThat(tree.sema).isInstanceOf(JSema.class); + if (input == a) { + var cls = (ClassTree) tree.types().getFirst(); + var field = (VariableTree) cls.members().getFirst(); + assertThat(field.symbol().type().fullyQualifiedName()).isEqualTo("p.B"); + assertThat(field.symbol().type().symbol().declaration()).isNull(); + } + assertThat(tree.sema.getClassType("p.Unsupplied").isUnknown()).isTrue(); + } catch (IOException failure) { + throw new AssertionError(failure); + } + }); + assertThat(trees.getFirst().sema.getClassType("p.B").isUnknown()).isFalse(); + } finally { + monitor.done(); + } + } + assertThat(callbacks).containsExactly("A.java", "B.java"); + assertThatThrownBy(() -> trees.getFirst().sema.getClassType("java.lang.Integer")) + .isInstanceOf(IllegalStateException.class).hasMessage("PSI environment is closed"); + assertThat(ApplicationManager.getApplication()).isNull(); + } + + @Test + void failed_batch_retries_only_pending_inputs_using_psi_file_mode() throws IOException { + var files = List.of(input("A.java", "class A {}"), input("B.java", "class B {}"), input("C.java", "class C {}")); + var opened = new AtomicInteger(); + var callbacks = new ArrayList(); + var config = new JParserConfig.Batch(JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, List.of(), false) { + @Override + FrontendBackend backend() { + return configuration -> { + var delegate = new PsiFrontendBackend().open(configuration); + if (opened.getAndIncrement() != 0) { + return delegate; + } + return new FrontendSession() { + { + own(delegate::close); + } + + @Override + JavaTree.CompilationUnitTreeImpl parse(String name, String source) { + return delegate.parse(name, source); + } + + @Override + void parseBatch(FrontendBatch inputs, ProgressMonitor monitor, BiConsumer action) { + delegate.parseBatch(inputs, monitor, (file, unit) -> { + if (file == files.get(1)) { + throw new IllegalStateException("batch failure after A"); + } + action.accept(file, unit); + }); + } + }; + }; + } + }; + config.parse(files, () -> false, new AnalysisProgress(3), (file, result) -> { + callbacks.add(file.filename()); + assertThat(tree(result).sema).isInstanceOf(JSema.class); + }); + assertThat(callbacks).containsExactly("A.java", "B.java", "C.java"); + assertThat(opened).hasValue(3); + assertThat(ApplicationManager.getApplication()).isNull(); + } + + @Test + void syntax_failure_still_delivers_later_files_and_disposes_batch() throws IOException { + var results = new ArrayList(); + psiBatch().parse(List.of(input("A.java", "class A { void x( }"), input("B.java", "class B {}")), + () -> false, new AnalysisProgress(2), (file, result) -> results.add(result)); + assertThat(results).hasSize(2); + assertThatThrownBy(results.getFirst()::get).isInstanceOf(com.sonar.sslr.api.RecognitionException.class); + assertThat(tree(results.getLast()).sema).isInstanceOf(JSema.class); + assertThat(ApplicationManager.getApplication()).isNull(); + } + + @Test + void cancellation_during_lazy_callback_propagates_without_retry() throws IOException { + var canceled = new AtomicBoolean(); + var callbacks = new AtomicInteger(); + assertThatThrownBy(() -> psiBatch().parse(List.of(input("A.java", "class A {}"), input("B.java", "class B {}")), + canceled::get, new AnalysisProgress(2), (file, result) -> { + callbacks.incrementAndGet(); + canceled.set(true); + tree(result).sema.getClassType("java.lang.String"); + })).isInstanceOf(OperationCanceledException.class); + assertThat(callbacks).hasValue(1); + assertThat(ApplicationManager.getApplication()).isNull(); + } + + @Test + void cancellation_before_the_first_batch_callback_does_not_fallback() throws IOException { + var input = input("A.java", "class A {}"); + assertThatThrownBy(() -> psiBatch().parse(List.of(input), () -> true, new AnalysisProgress(1), + (file, result) -> { throw new AssertionError("Unexpected callback"); })).isInstanceOf(OperationCanceledException.class); + assertThat(ApplicationManager.getApplication()).isNull(); + } + + @Test + void file_session_preserves_interruption() { + try (var session = new PsiFrontendBackend().open(CONFIGURATION)) { + Thread.currentThread().interrupt(); + try { + assertThatThrownBy(() -> session.parse("A.java", "class A {}")).isInstanceOf(OperationCanceledException.class); + assertThat(Thread.currentThread().isInterrupted()).isTrue(); + } finally { + Thread.interrupted(); + } + } + assertThat(ApplicationManager.getApplication()).isNull(); + } + + @Test + void single_frontend_reaches_child_jvm_despite_legacy_selection() throws Exception { + for (boolean inheritEnvironment : List.of(true, false)) { + var process = new ProcessBuilder(Path.of(System.getProperty("java.home"), "bin", "java").toString(), + "-cp", System.getProperty("java.class.path"), BackendProbe.class.getName()).redirectErrorStream(true); + process.environment().put("SONAR_JAVA_FRONTEND", inheritEnvironment ? "ecj" : "invalid"); + process.command().add(1, "-Dsonar.java.frontend=ecj"); + var child = process.start(); + try { + assertThat(child.waitFor(30, TimeUnit.SECONDS)).isTrue(); + String output = new String(child.getInputStream().readAllBytes(), StandardCharsets.UTF_8); + assertThat(child.exitValue()).as(output).isZero(); + assertThat(output).contains("backend=PSI"); + } finally { + child.destroyForcibly(); + } + } + } + + public static class BackendProbe { + public static void main(String[] args) { + try (var parsed = FrontendParser.parse(JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, List.of(), "A.java", "class A {}")) { + if (!(parsed.tree().sema instanceof JSema)) { + throw new AssertionError("Wrong backend"); + } + System.out.println("backend=PSI"); + } + if (ApplicationManager.getApplication() != null) { + throw new AssertionError("Leaked PSI application"); + } + System.exit(0); + } + } + + private static JParserConfig psiBatch() { + return new JParserConfig.Batch(JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, List.of(), false) { + @Override + FrontendBackend backend() { + return new PsiFrontendBackend(); + } + }; + } + + private static JavaTree.CompilationUnitTreeImpl tree(JParserConfig.Result result) { + try { + return result.get(); + } catch (Exception failure) { + throw new AssertionError(failure); + } + } + + private static InputFile input(String name, String source) throws IOException { + var file = mock(InputFile.class); + when(file.filename()).thenReturn(name); + when(file.absolutePath()).thenReturn(Path.of("target", "psi-execution", name).toAbsolutePath().toString()); + when(file.charset()).thenReturn(StandardCharsets.UTF_8); + when(file.contents()).thenReturn(source); + return file; + } +} diff --git a/java-frontend/src/test/java/org/sonar/java/model/PsiSemanticTestSupport.java b/java-frontend/src/test/java/org/sonar/java/model/PsiSemanticTestSupport.java new file mode 100644 index 00000000000..ab1fad30daa --- /dev/null +++ b/java-frontend/src/test/java/org/sonar/java/model/PsiSemanticTestSupport.java @@ -0,0 +1,80 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import java.io.File; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.util.List; +import org.sonar.java.psi.JavaPsiConfiguration; +import org.sonar.java.psi.JavaPsiEnvironment; +import org.sonar.plugins.java.api.JavaVersion; + +final class PsiSemanticTestSupport implements AutoCloseable { + private final JavaPsiEnvironment environment; + private final JavaTree.CompilationUnitTreeImpl tree; + private final List trees; + + private PsiSemanticTestSupport(JavaPsiEnvironment environment, List trees) { + this.environment = environment; + this.trees = trees; + this.tree = trees.getFirst(); + } + + static PsiSemanticTestSupport open(String name, String source, List classpath, JavaVersion version) { + return open(List.of(new JavaPsiEnvironment.SourceSnapshot(Path.of(name), source, StandardCharsets.UTF_8)), classpath, version); + } + + static PsiSemanticTestSupport open(List sources, List classpath, JavaVersion version) { + var configuration = new JavaPsiConfiguration(null, classpath.stream().map(File::toPath).toList(), + Integer.parseInt(version.effectiveJavaVersionAsString()), version.arePreviewFeaturesEnabled(), false); + var environment = JavaPsiEnvironment.open(configuration, sources.stream() + .map(source -> new JavaPsiEnvironment.SourceSnapshot(source.path(), PsiTokenIndex.unicodeInput(source.contents()).text(), source.charset())).toList()); + try { + var cleaner = FrontendResources.idempotent(environment::close); + var trees = environment.read((project, files) -> { + var result = new java.util.ArrayList(); + for (int i = 0; i < files.size(); i++) { + var tree = JParser.convert(environment, project, files.get(i), configuration, sources.get(i).contents(), cleaner); + result.add(tree); + } + return List.copyOf(result); + }); + return new PsiSemanticTestSupport(environment, trees); + } catch (RuntimeException | Error failure) { + try { + environment.close(); + } catch (RuntimeException | Error cleanupFailure) { + failure.addSuppressed(cleanupFailure); + } + throw failure; + } + } + + JavaTree.CompilationUnitTreeImpl tree() { + return tree; + } + + List trees() { + return trees; + } + + @Override + public void close() { + environment.close(); + } +} diff --git a/java-frontend/src/test/java/org/sonar/java/model/PsiSyntaxCorpusTest.java b/java-frontend/src/test/java/org/sonar/java/model/PsiSyntaxCorpusTest.java new file mode 100644 index 00000000000..162a3abc424 --- /dev/null +++ b/java-frontend/src/test/java/org/sonar/java/model/PsiSyntaxCorpusTest.java @@ -0,0 +1,72 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.sonar.java.cfg.CFG; +import org.sonar.plugins.java.api.tree.ClassTree; +import org.sonar.plugins.java.api.tree.MethodTree; +import org.sonar.plugins.java.api.tree.Tree; + +import static org.assertj.core.api.Assertions.assertThat; + +class PsiSyntaxCorpusTest { + @ParameterizedTest(name = "{0}") + @MethodSource("files") + void repository_sources_preserve_tree_links_tokens_and_trivia(Path path) throws IOException { + String source = Files.readString(path); + var tree = PsiSyntaxTestSupport.parse(path.getFileName().toString(), source); + PsiSyntaxTestSupport.assertStructure(tree, source); + } + + static Stream files() throws IOException { + try (var paths = Files.walk(Path.of("src"))) { + return paths.filter(path -> path.startsWith(Path.of("src/main/java")) || path.startsWith(Path.of("src/test/java"))) + .filter(path -> path.toString().endsWith(".java")).sorted().toList().stream(); + } + } + + @ParameterizedTest + @MethodSource("controlFlow") + void control_flow_preserves_branches_and_finally_blocks(String method, int blockCount, List terminators, int edgeCount, int finallyCount) { + var tree = PsiSyntaxTestSupport.parse("A.java", "class A {" + method + "}"); + var declaration = (MethodTree) ((ClassTree) tree.types().getFirst()).members().getFirst(); + var cfg = CFG.build(declaration); + assertThat(cfg.blocks()).hasSize(blockCount); + assertThat(cfg.blocks().stream().map(CFG.Block::terminator).filter(java.util.Objects::nonNull).map(Tree::kind)) + .containsExactlyInAnyOrderElementsOf(terminators); + assertThat(cfg.blocks().stream().mapToInt(block -> block.successors().size()).sum()).isEqualTo(edgeCount); + assertThat(cfg.blocks().stream().filter(CFG.Block::isFinallyBlock).count()).isEqualTo(finallyCount); + } + + static Stream controlFlow() { + return Stream.of( + Arguments.of("void m(){ outer:for(int i=0;i<3;i++){if(i==1)continue outer;while(flag){if(flag)break;else return;}} }", 10, List.of(Tree.Kind.FOR_STATEMENT, Tree.Kind.IF_STATEMENT, Tree.Kind.CONTINUE_STATEMENT, Tree.Kind.WHILE_STATEMENT, Tree.Kind.IF_STATEMENT, Tree.Kind.BREAK_STATEMENT, Tree.Kind.RETURN_STATEMENT), 13, 0), + Arguments.of("int m(){return switch(x){case 1,2->3;case 4->{yield 5;}default->0;};}", 6, List.of(Tree.Kind.YIELD_STATEMENT, Tree.Kind.YIELD_STATEMENT, Tree.Kind.YIELD_STATEMENT, Tree.Kind.SWITCH_EXPRESSION, Tree.Kind.RETURN_STATEMENT), 7, 0), + Arguments.of("void m(){switch(x){case 1:case 2:x++;break;default:while(flag){break;}}}", 6, List.of(Tree.Kind.BREAK_STATEMENT, Tree.Kind.WHILE_STATEMENT, Tree.Kind.BREAK_STATEMENT, Tree.Kind.SWITCH_STATEMENT), 7, 0), + Arguments.of("void m(){try{if(flag)return;throw new E();}finally{synchronized(this){x++;}}}", 8, List.of(Tree.Kind.IF_STATEMENT, Tree.Kind.RETURN_STATEMENT, Tree.Kind.THROW_STATEMENT, Tree.Kind.SYNCHRONIZED_STATEMENT), 8, 2), + Arguments.of("void m(){do{if(flag)break;x++;}while(flag);assert flag:x;}", 6, List.of(Tree.Kind.IF_STATEMENT, Tree.Kind.BREAK_STATEMENT, Tree.Kind.DO_STATEMENT), 7, 0) + ); + } +} diff --git a/java-frontend/src/test/java/org/sonar/java/model/PsiSyntaxTestSupport.java b/java-frontend/src/test/java/org/sonar/java/model/PsiSyntaxTestSupport.java new file mode 100644 index 00000000000..413dcdee6bc --- /dev/null +++ b/java-frontend/src/test/java/org/sonar/java/model/PsiSyntaxTestSupport.java @@ -0,0 +1,102 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.Collections; +import java.util.EnumSet; +import java.util.IdentityHashMap; +import java.util.List; +import java.util.Set; +import org.sonar.java.psi.JavaPsiConfiguration; +import org.sonar.java.psi.JavaPsiEnvironment; +import org.sonar.plugins.java.api.location.Range; +import org.sonar.plugins.java.api.tree.SyntaxToken; +import org.sonar.plugins.java.api.tree.Tree; + +import static org.assertj.core.api.Assertions.assertThat; + +final class PsiSyntaxTestSupport { + private PsiSyntaxTestSupport() { + } + + static JavaTree.CompilationUnitTreeImpl parse(String unitName, String source) { + var configuration = new JavaPsiConfiguration(null, List.of(), 26, true, true); + try (var environment = JavaPsiEnvironment.open(configuration, + List.of(new JavaPsiEnvironment.SourceSnapshot(Path.of(unitName), source, StandardCharsets.UTF_8)))) { + return environment.read((project, files) -> new JParser(files.getFirst()).convert()); + } + } + + static void assertStructure(JavaTree root, String source) { + var nodes = nodes(root); + for (var node : nodes) { + assertThat(((JavaTree) node).root).as("root of %s", node.kind()).isSameAs(root); + if (node.parent() != null) { + assertThat(children(node.parent())).as("parent of %s", node.kind()).contains(node); + } + } + int lineCount = source.split("\\r\\n?|\\n", -1).length; + for (var node : nodes) { + if (node instanceof SyntaxToken token) { + assertRange(token.range(), lineCount); + token.trivias().forEach(trivia -> assertRange(trivia.range(), lineCount)); + } + } + } + + static Set kinds(JavaTree root) { + var result = EnumSet.noneOf(Tree.Kind.class); + nodes(root).forEach(tree -> { + result.add(tree.kind()); + if (tree instanceof SyntaxToken token && !token.trivias().isEmpty()) { + result.add(Tree.Kind.TRIVIA); + } + }); + return result; + } + + private static void assertRange(Range range, int lineCount) { + assertThat(range.start().line()).isBetween(1, lineCount); + assertThat(range.end().line()).isBetween(range.start().line(), lineCount); + assertThat(range.start().columnOffset()).isNotNegative(); + assertThat(range.end().columnOffset()).isNotNegative(); + if (range.start().line() == range.end().line()) { + assertThat(range.end().columnOffset()).isGreaterThanOrEqualTo(range.start().columnOffset()); + } + } + + private static List nodes(Tree root) { + List result = new ArrayList<>(); + Set visited = Collections.newSetFromMap(new IdentityHashMap<>()); + collect(root, result, visited); + return result; + } + + private static void collect(Tree tree, List result, Set visited) { + if (visited.add(tree)) { + result.add(tree); + children(tree).forEach(child -> collect(child, result, visited)); + } + } + + private static List children(Tree tree) { + return tree.is(Tree.Kind.TOKEN, Tree.Kind.INFERED_TYPE) ? List.of() : ((JavaTree) tree).getChildren(); + } +} diff --git a/java-frontend/src/test/java/org/sonar/java/model/SemanticCompatibilityTest.java b/java-frontend/src/test/java/org/sonar/java/model/SemanticCompatibilityTest.java new file mode 100644 index 00000000000..0e665b9181e --- /dev/null +++ b/java-frontend/src/test/java/org/sonar/java/model/SemanticCompatibilityTest.java @@ -0,0 +1,203 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import java.util.ArrayList; +import java.util.List; +import org.junit.jupiter.api.Test; +import org.sonar.java.test.TestResourceScope; +import org.sonar.plugins.java.api.semantic.Symbol; +import org.sonar.plugins.java.api.semantic.Type; +import org.sonar.plugins.java.api.tree.BaseTreeVisitor; +import org.sonar.plugins.java.api.tree.ClassTree; +import org.sonar.plugins.java.api.tree.CompilationUnitTree; +import org.sonar.plugins.java.api.tree.IdentifierTree; +import org.sonar.plugins.java.api.tree.MemberSelectExpressionTree; +import org.sonar.plugins.java.api.tree.MethodInvocationTree; +import org.sonar.plugins.java.api.tree.MethodTree; +import org.sonar.plugins.java.api.tree.NewClassTree; +import org.sonar.plugins.java.api.tree.VariableTree; + +import static org.assertj.core.api.Assertions.assertThat; + +@TestResourceScope.Scoped +class SemanticCompatibilityTest { + @Test + void implicit_constructor_has_a_semantic_member_without_a_source_member() { + var tree = parse("class A { A value = new A(); }"); + var cls = (ClassTree) tree.types().getFirst(); + var creation = (NewClassTree) ((VariableTree) cls.members().getFirst()).initializer(); + var constructor = (Symbol.MethodSymbol) creation.identifier().symbolType().symbol().lookupSymbols("").iterator().next(); + var called = (Symbol.MethodSymbol) ((IdentifierTree) creation.identifier()).symbol(); + assertThat(called.isUnknown()).isFalse(); + assertThat(called.name()).isEqualTo(""); + assertThat(called.signature()).isEqualTo("A#()V"); + assertThat(called.returnType().type().isVoid()).isTrue(); + assertThat(called.declaration()).isNull(); + assertThat(constructor).isEqualTo(called); + assertThat(cls.members()).hasSize(1); + } + + @Test + void array_length_has_a_final_variable_symbol_and_unknown_owner_type() { + var tree = parse("class A { int size(String[] values) { return values.length; } }"); + var select = new ArrayList(); + tree.accept(new BaseTreeVisitor() { + @Override + public void visitMemberSelectExpression(MemberSelectExpressionTree member) { + if (member.identifier().name().equals("length")) { + select.add(member); + } + super.visitMemberSelectExpression(member); + } + }); + var symbol = select.getFirst().identifier().symbol(); + assertThat(symbol.isVariableSymbol()).isTrue(); + assertThat(symbol.type().is("int")).isTrue(); + assertThat(symbol.isFinal()).isTrue(); + assertThat(symbol.owner().type()).isSameAs(Type.UNKNOWN); + assertThat(symbol.declaration()).isNull(); + } + + @Test + void record_accessors_and_compact_constructor_keep_declaration_signatures() { + var tree = parse("record R(String value) { R { value = value.trim(); } static String use() { return new R(\"x\").value(); } }"); + var cls = (ClassTree) tree.types().getFirst(); + var methods = calls(tree); + var accessor = methods.stream().map(MethodInvocationTree::methodSymbol).filter(s -> s.name().equals("value")).findFirst().orElseThrow(); + assertThat(accessor.signature()).isEqualTo("R#value()Ljava/lang/String;"); + assertThat(accessor.returnType().type().is("java.lang.String")).isTrue(); + assertThat(accessor.declaration()).isNull(); + var constructor = (MethodTree) cls.members().getFirst(); + assertThat(constructor.symbol().signature()).isEqualTo("R#(Ljava/lang/String;)V"); + assertThat(constructor.symbol().parameterTypes()).extracting(Type::fullyQualifiedName).containsExactly("java.lang.String"); + assertThat(cls.symbol().lookupSymbols("value")).hasSize(2); + } + + @Test + void parameterized_owner_and_field_symbols_retain_the_call_context() { + var tree = parse("class Box { T value; T get() { return value; } static void use(Box b) { String v = b.value; b.get(); } }"); + var cls = (ClassTree) tree.types().getFirst(); + var method = (MethodTree) cls.members().get(1); + assertThat(method.symbol().owner()).isSameAs(cls.symbol()); + var call = calls(tree).getFirst().methodSymbol(); + assertThat(call.owner().type().typeArguments()).extracting(Type::fullyQualifiedName).containsExactly("java.lang.String"); + assertThat(call.returnType().type().is("java.lang.String")).isTrue(); + var symbols = new ArrayList(); + tree.accept(new BaseTreeVisitor() { + @Override + public void visitMemberSelectExpression(MemberSelectExpressionTree member) { + if (member.identifier().name().equals("value")) { + symbols.add(member.identifier().symbol()); + } + super.visitMemberSelectExpression(member); + } + }); + assertThat(symbols.getFirst().type().is("java.lang.String")).isTrue(); + assertThat(symbols.getFirst().declaration()).isSameAs(cls.members().getFirst()); + assertThat(symbols.getFirst().enclosingClass()).isSameAs(symbols.getFirst().owner()); + } + + @Test + void invalid_candidates_do_not_hide_independent_resolved_calls() { + var tree = parse("class A { void pick(String s) {} void pick(Integer i) {} void use() { pick(null); missing(); \"x\".trim(); } }"); + var methods = calls(tree); + assertThat(methods.get(0).methodSymbol().signature()).isEqualTo("A#pick(Ljava/lang/String;)V"); + assertThat(methods.get(1).methodSymbol().isUnknown()).isTrue(); + assertThat(methods.get(2).methodSymbol().signature()).isEqualTo("java.lang.String#trim()Ljava/lang/String;"); + assertThat(methods.get(2).symbolType().is("java.lang.String")).isTrue(); + } + + @Test + void source_package_annotations_are_not_merged_into_package_metadata() { + var tree = JParserTestUtils.parsePackage("@Deprecated package sample;"); + assertThat(tree.packageDeclaration().packageName().symbolType().symbol().metadata().annotations()).isEmpty(); + } + + @Test + void annotation_shorthand_preserves_explicit_arrays_and_scalar_defaults() { + var tree = parse(""" + @interface Values { String[] value() default "default"; Class type() default String.class; } + @Values("explicit") class A {} + """); + var annotation = (ClassTree) tree.types().getFirst(); + var value = ((MethodTree) annotation.members().getFirst()).symbol().defaultValue(); + assertThat(value).isEqualTo("default"); + var literal = ((MethodTree) annotation.members().get(1)).symbol().defaultValue(); + assertThat(((Symbol.TypeSymbol) literal).type().is("java.lang.String")).isTrue(); + var cls = (ClassTree) tree.types().get(1); + assertThat((Object[]) cls.symbol().metadata().annotations().getFirst().values().getFirst().value()).containsExactly("explicit"); + } + + @Test + void inaccessible_and_inapplicable_calls_keep_only_supported_recovery() { + var tree = parse(""" + class Secret { private String hidden() { return ""; } } + class A { void accept(String s) {} void use(Secret s) { s.hidden(); accept(1); } } + """); + var calls = calls(tree); + assertThat(calls.getFirst().methodSymbol().signature()).isEqualTo("Secret#hidden()Ljava/lang/String;"); + assertThat(calls.get(1).methodSymbol().signature()).isEqualTo("A#accept(Ljava/lang/String;)V"); + } + + @Test + void nested_generic_owners_keep_enclosing_substitutions() { + var tree = parse(""" + class Outer { + class Inner { U get() { return null; } } + void use(Outer.Inner value) { value.get(); } + } + """); + var method = calls(tree).getFirst().methodSymbol(); + assertThat(method.owner().type().typeArguments()).extracting(Type::fullyQualifiedName).containsExactly("java.lang.Integer"); + assertThat(method.owner().owner().type().typeArguments()).extracting(Type::fullyQualifiedName).containsExactly("java.lang.String"); + assertThat(method.enclosingClass()).isSameAs(method.owner()); + } + + @Test + void intersection_lambda_targets_preserve_the_functional_signature() { + var tree = parse(""" + class A { Object value = (java.util.function.Function & java.io.Serializable) text -> text.length(); } + """); + var lambdas = new ArrayList(); + tree.accept(new BaseTreeVisitor() { + @Override + public void visitLambdaExpression(org.sonar.plugins.java.api.tree.LambdaExpressionTree lambda) { + lambdas.add(lambda); + super.visitLambdaExpression(lambda); + } + }); + assertThat(lambdas.getFirst().symbol().parameterTypes()).extracting(Type::fullyQualifiedName).containsExactly("java.lang.String"); + assertThat(lambdas.getFirst().symbol().returnType().type().is("java.lang.Integer")).isTrue(); + } + + private static JavaTree.CompilationUnitTreeImpl parse(String source) { + return (JavaTree.CompilationUnitTreeImpl) JParserTestUtils.parse(source); + } + + private static List calls(CompilationUnitTree tree) { + var result = new ArrayList(); + tree.accept(new BaseTreeVisitor() { + @Override + public void visitMethodInvocation(MethodInvocationTree call) { + result.add(call); + super.visitMethodInvocation(call); + } + }); + return result; + } +} diff --git a/java-frontend/src/test/java/org/sonar/java/model/SemanticFixture.java b/java-frontend/src/test/java/org/sonar/java/model/SemanticFixture.java index 09b580fed9b..3358acbd1e5 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/SemanticFixture.java +++ b/java-frontend/src/test/java/org/sonar/java/model/SemanticFixture.java @@ -29,10 +29,12 @@ /** Backend-aware source fixtures expose Sonar declarations and retain the parser through lazy queries. */ final class SemanticFixture implements AutoCloseable { - private final FrontendParser.ParsedFile parsed; + private final JavaTree.CompilationUnitTreeImpl tree; + private final Runnable cleaner; private SemanticFixture(FrontendParser.ParsedFile parsed) { - this.parsed = parsed; + tree = parsed.tree(); + cleaner = parsed::close; } static SemanticFixture scoped(String source) { @@ -48,7 +50,7 @@ static SemanticFixture open(FrontendBackend backend, FrontendConfiguration confi } JavaTree.CompilationUnitTreeImpl tree() { - return parsed.tree(); + return tree; } ClassTree declaration(int index) { @@ -73,6 +75,6 @@ List annotations(Symbol symbol) { @Override public void close() { - parsed.close(); + cleaner.run(); } } diff --git a/java-frontend/src/test/java/org/sonar/java/model/SemanticTestSupport.java b/java-frontend/src/test/java/org/sonar/java/model/SemanticTestSupport.java new file mode 100644 index 00000000000..f4b286ed115 --- /dev/null +++ b/java-frontend/src/test/java/org/sonar/java/model/SemanticTestSupport.java @@ -0,0 +1,134 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import java.util.List; +import org.sonar.java.model.declaration.ClassTreeImpl; +import org.sonar.java.model.declaration.VariableTreeImpl; +import org.sonar.java.model.expression.IdentifierTreeImpl; +import org.sonar.plugins.java.api.semantic.Symbol; +import org.sonar.plugins.java.api.semantic.Type; +import org.sonar.plugins.java.api.tree.ClassTree; +import org.sonar.plugins.java.api.tree.IdentifierTree; +import org.sonar.plugins.java.api.tree.ImportTree; +import org.sonar.plugins.java.api.tree.LambdaExpressionTree; +import org.sonar.plugins.java.api.tree.MethodInvocationTree; +import org.sonar.plugins.java.api.tree.MethodTree; +import org.sonar.plugins.java.api.tree.Tree; +import org.sonar.plugins.java.api.tree.TypeParameterTree; +import org.sonar.plugins.java.api.tree.VariableTree; + +public final class SemanticTestSupport { + private SemanticTestSupport() { + } + + static Type type(Object tree) { + Type value; + if (tree instanceof AbstractTypedTree typed) { + value = typed.symbolType(); + } else if (tree instanceof ClassTree cls) { + value = cls.symbol().type(); + } else if (tree instanceof TypeParameterTree parameter) { + value = parameter.symbol().type(); + } else { + throw new IllegalArgumentException("No type: " + tree.getClass()); + } + return value == Type.UNKNOWN ? null : value; + } + + static Symbol symbol(Object tree) { + Symbol value; + if (tree instanceof IdentifierTree identifier) { + value = identifier.symbol(); + } else if (tree instanceof VariableTree variable) { + value = variable.symbol(); + } else if (tree instanceof ClassTree cls) { + value = cls.symbol(); + } else if (tree instanceof MethodTree method) { + value = method.symbol(); + } else if (tree instanceof ImportTree imported) { + value = imported.symbol(); + } else if (tree instanceof MethodInvocationTree invocation) { + value = invocation.methodSymbol(); + } else if (tree instanceof LambdaExpressionTree lambda) { + value = lambda.symbol(); + } else { + throw new IllegalArgumentException("No symbol: " + tree.getClass()); + } + return value == Symbol.UNKNOWN_SYMBOL || value == Symbol.MethodSymbol.UNKNOWN_METHOD || value instanceof Symbol.LabelSymbol ? null : value; + } + + static Symbol.MethodSymbol method(Object tree) { + return (Symbol.MethodSymbol) symbol(tree); + } + + static Symbol.VariableSymbol symbol(org.sonar.java.model.declaration.VariableTreeImpl tree) { + return tree.symbol() instanceof Symbol.VariableSymbol variable ? variable : null; + } + + static List usages(Object value) { + Symbol symbol = value instanceof Type type ? type.symbol() : (Symbol) value; + var usages = symbol.usages(); + return usages.isEmpty() ? null : usages; + } + + static Tree declaration(Object value) { + return (value instanceof Type type ? type.symbol() : (Symbol) value).declaration(); + } + + static Symbol specialField(Type type, boolean isSuper) { + var symbol = (JTypeSymbol) type.symbol(); + return isSuper ? symbol.superSymbol : symbol.thisSymbol; + } + + static boolean isLambda(Symbol symbol) { + return symbol instanceof JMethodSymbol psi && psi.isLambda(); + } + + static Symbol.MethodSymbol initializer(Symbol.TypeSymbol owner, boolean isStatic) { + var psi = (JTypeSymbol) owner; + return psi.sema.read(() -> psi.sema.initializer(owner, isStatic)); + } + + static int dimensions(Type type) { + return type instanceof Type.ArrayType array && type.isArray() ? 1 + dimensions(array.elementType()) : 0; + } + public static void clearType(JavaTree tree) { + if (tree instanceof AbstractTypedTree typed) { + typed.type = SemanticValues.UNKNOWN_TYPE; + } else if (tree instanceof ClassTreeImpl cls) { + cls.typeSymbol = SemanticValues.UNKNOWN_TYPE_SYMBOL; + } else if (tree instanceof TypeParameterTreeImpl parameter) { + parameter.typeSymbol = SemanticValues.UNKNOWN_SYMBOL; + } else { + throw new IllegalArgumentException("No type attachment: " + tree.getClass()); + } + if (tree instanceof KeywordThis || tree instanceof KeywordSuper) { + ((IdentifierTreeImpl) tree).symbolSupplier = SemanticValues.UNKNOWN_SYMBOL; + } + } + + public static void clearSymbol(JavaTree tree) { + if (tree instanceof IdentifierTreeImpl identifier) { + identifier.symbolSupplier = SemanticValues.UNKNOWN_SYMBOL; + } else if (tree instanceof VariableTreeImpl variable) { + variable.variableSymbol = SemanticValues.UNKNOWN_SYMBOL; + } else { + throw new IllegalArgumentException("No symbol attachment: " + tree.getClass()); + } + } +} diff --git a/java-frontend/src/test/java/org/sonar/java/model/SymbolsTest.java b/java-frontend/src/test/java/org/sonar/java/model/SymbolsTest.java index 7c7e42e7b1e..4894fc4a1c6 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/SymbolsTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/SymbolsTest.java @@ -36,7 +36,6 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; -import static org.sonar.java.model.EcjTestSupport.sema; @TestResourceScope.Scoped class SymbolsTest { @@ -206,8 +205,8 @@ private static void assertCommonProperties(Symbol unknownSymbol) { @Test void testIsAnnotation() { - JSema sema = sema(((JavaTree.CompilationUnitTreeImpl) JParserTestUtils.parse(""))); - Type objectType = sema.type(sema.resolveType("java.lang.Object")); + var sema = ((JavaTree.CompilationUnitTreeImpl) JParserTestUtils.parse("")).sema; + Type objectType = sema.getClassType("java.lang.Object"); JavaTree.CompilationUnitTreeImpl cu = (JavaTree.CompilationUnitTreeImpl) JParserTestUtils.parse("@interface Anno { Unknown u; }"); ClassTreeImpl anno = (ClassTreeImpl) cu.types().get(0); diff --git a/java-frontend/src/test/java/org/sonar/java/model/declaration/ClassTreeImplTest.java b/java-frontend/src/test/java/org/sonar/java/model/declaration/ClassTreeImplTest.java index 4a8660d3949..6ab0c2a80ca 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/declaration/ClassTreeImplTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/declaration/ClassTreeImplTest.java @@ -30,7 +30,7 @@ import org.sonar.plugins.java.api.tree.VariableTree; import static org.assertj.core.api.Assertions.assertThat; -import static org.sonar.java.model.EcjTestSupport.clearType; +import static org.sonar.java.model.SemanticTestSupport.clearType; import static org.sonar.java.model.assertions.TreeAssert.assertThat; @TestResourceScope.Scoped diff --git a/java-frontend/src/test/java/org/sonar/java/utils/JavaFileTypeClassifierTest.java b/java-frontend/src/test/java/org/sonar/java/utils/JavaFileTypeClassifierTest.java index d067197ffe6..4cb2c99b80d 100644 --- a/java-frontend/src/test/java/org/sonar/java/utils/JavaFileTypeClassifierTest.java +++ b/java-frontend/src/test/java/org/sonar/java/utils/JavaFileTypeClassifierTest.java @@ -22,7 +22,8 @@ import org.sonar.api.batch.fs.InputFile; import org.sonar.api.config.Configuration; import org.sonar.java.TestUtils; -import org.sonar.java.ast.JavaAstScanner; +import org.sonar.java.model.JParserTestUtils; +import org.sonar.java.test.TestResourceScope; import org.sonar.java.test.classpath.TestClasspathUtils; import org.sonar.java.testing.VisitorsBridgeForTests; import org.sonar.plugins.java.api.JavaFileScannerContext; @@ -32,6 +33,7 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +@TestResourceScope.Scoped class JavaFileTypeClassifierTest { /** @@ -157,7 +159,9 @@ private static JavaFileScannerContext contextFor(String filePath) { var bridge = new VisitorsBridgeForTests.Builder(List.of()) .enableSemanticWithProjectClasspath(classpath) .build(); - JavaAstScanner.scanSingleFileForTests(TestUtils.inputFile(filePath), bridge); + bridge.setCurrentFile(TestUtils.inputFile(filePath)); + bridge.visitFile(JParserTestUtils.parse(new java.io.File(filePath), classpath), false); + bridge.endOfAnalysis(); return bridge.testContexts().get(0); } diff --git a/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaSensorTest.java b/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaSensorTest.java index c034ba5b0f7..d3601234b51 100644 --- a/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaSensorTest.java +++ b/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaSensorTest.java @@ -443,6 +443,8 @@ private void assertJasperIsInvoked(MapSettings settings) throws IOException { ArgumentCaptor scannerContext = ArgumentCaptor.forClass(JavaFileScannerContext.class); verify(testCodeVisitor, times(1)).scanFile(scannerContext.capture()); assertThat(scannerContext.getValue().getInputFile()).isSameAs(generatedFile); + String expectedSema = "JSema"; + assertThat(scannerContext.getValue().getSemanticModel().getClass().getSimpleName()).isEqualTo(expectedSema); // normal visitors are not invoked on generated files verify(javaFileScanner, never()).scanFile(any()); From 8c6424f5b592b01db0f5e9f35c1dfc94e5892382 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Aur=C3=A9lien=20Coet?= Date: Mon, 2 Nov 2026 13:32:24 +0100 Subject: [PATCH 2/2] Remove ECJ dependencies and enforce frontend boundaries --- .../FrontendDependencyValidator.java | 65 +++++++++++++++ java-frontend/pom.xml | 5 -- .../java/model/FrontendArchitectureTest.java | 81 +++++++++++++++++++ pom.xml | 27 +++++++ sonar-java-plugin/pom.xml | 17 +++- 5 files changed, 189 insertions(+), 6 deletions(-) create mode 100644 build-support/FrontendDependencyValidator.java create mode 100644 java-frontend/src/test/java/org/sonar/java/model/FrontendArchitectureTest.java diff --git a/build-support/FrontendDependencyValidator.java b/build-support/FrontendDependencyValidator.java new file mode 100644 index 00000000000..c44c16a2723 --- /dev/null +++ b/build-support/FrontendDependencyValidator.java @@ -0,0 +1,65 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; + +public final class FrontendDependencyValidator { + private FrontendDependencyValidator() { + } + + public static void main(String[] args) throws IOException { + if (args.length != 1) { + throw new IllegalArgumentException("Expected the packaged plugin JAR path"); + } + try (var input = Files.newInputStream(Path.of(args[0]))) { + inspect(input, args[0]); + } + System.out.println("Packaged frontend contains no ECJ or JDT core classes"); + } + + private static void inspect(InputStream input, String path) throws IOException { + try (var zip = new ZipInputStream(input)) { + ZipEntry entry; + while ((entry = zip.getNextEntry()) != null) { + String name = entry.getName(); + String location = path + "!/" + name; + if (name.contains("jdt-package") || name.contains("org.eclipse.jdt.core") || name.matches(".*(?:^|/)ecj[-./].*")) { + throw new IllegalStateException("Forbidden compiler artifact: " + location); + } + if (name.endsWith(".class") && name.contains("org/eclipse/jdt/") && !name.contains("org/eclipse/jdt/annotation/")) { + throw new IllegalStateException("Forbidden compiler class: " + location); + } + if (name.endsWith(".jar")) { + inspect(new ByteArrayInputStream(zip.readAllBytes()), location); + } else if (name.endsWith(".class")) { + String bytes = new String(zip.readAllBytes(), StandardCharsets.ISO_8859_1); + for (String prefix : java.util.List.of("org/eclipse/jdt/core/", "org/eclipse/jdt/internal/", "org.eclipse.jdt.core.", "org.eclipse.jdt.internal.")) { + if (bytes.contains(prefix)) { + throw new IllegalStateException("Forbidden compiler reference: " + location); + } + } + } + } + } + } +} diff --git a/java-frontend/pom.xml b/java-frontend/pom.xml index 8ebcdb99a78..eb4ad1438be 100644 --- a/java-frontend/pom.xml +++ b/java-frontend/pom.xml @@ -28,11 +28,6 @@ - - ${project.groupId} - jdt-package - 1.9.0.1840 - com.jetbrains.intellij.java java-psi diff --git a/java-frontend/src/test/java/org/sonar/java/model/FrontendArchitectureTest.java b/java-frontend/src/test/java/org/sonar/java/model/FrontendArchitectureTest.java new file mode 100644 index 00000000000..1264ebb1a2f --- /dev/null +++ b/java-frontend/src/test/java/org/sonar/java/model/FrontendArchitectureTest.java @@ -0,0 +1,81 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.model; + +import java.io.File; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.jar.JarFile; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +class FrontendArchitectureTest { + @Test + void obsolete_classes_are_unavailable_on_the_test_classpath() throws Exception { + for (String name : java.util.List.of("org.eclipse.jdt.core.dom.ASTParser", "org.eclipse.jdt.internal.compiler.Compiler", + "org.sonar.java.model.PsiSema", "org.sonar.java.model.PsiType", "org.sonar.java.model.PsiSymbol", + "org.sonar.java.model.PsiTypeSymbol", "org.sonar.java.model.PsiMethodSymbol", "org.sonar.java.model.PsiVariableSymbol", + "org.sonar.java.model.PsiPackageSymbol", "org.sonar.java.model.PsiSymbolMetadata", "org.sonar.java.model.PsiTreeConverter", + "org.sonar.java.model.PsiFrontendParser")) { + assertThatThrownBy(() -> Class.forName(name)).isInstanceOf(ClassNotFoundException.class); + } + for (String entry : System.getProperty("java.class.path").split(File.pathSeparator)) { + var path = Path.of(entry); + if (entry.endsWith(".jar")) { + try (var jar = new JarFile(path.toFile())) { + assertThat(jar.stream().map(java.util.jar.JarEntry::getName).filter(name -> name.endsWith(".class"))) + .as(entry).noneMatch(FrontendArchitectureTest::isCompilerClass); + } + } else if (Files.isDirectory(path)) { + try (var files = Files.walk(path)) { + assertThat(files.filter(file -> file.toString().endsWith(".class")).map(file -> path.relativize(file).toString().replace('\\', '/'))) + .as(entry).noneMatch(FrontendArchitectureTest::isCompilerClass); + } + } + } + } + + @Test + void frontend_sources_have_no_compiler_imports() throws Exception { + try (var files = Files.walk(Path.of("src"))) { + for (var path : files.filter(file -> file.toString().endsWith(".java")).toList()) { + assertThat(Files.readAllLines(path).stream().filter(line -> line.startsWith("import "))) + .as(path.toString()).noneMatch(line -> line.contains("org.eclipse.jdt.") && !line.contains("org.eclipse.jdt.annotation.")); + } + } + } + + @Test + void unresolved_lookup_recovers_without_a_compiler_binding() { + try (var parsed = FrontendParser.parse(JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, java.util.List.of(), "C.java", "class C {}")) { + assertThat(parsed.tree().sema).isInstanceOf(JSema.class); + var string = parsed.tree().sema.getClassType("java.lang.String"); + assertThat(string).isInstanceOf(JType.class); + assertThat(string.symbol()).isInstanceOf(JTypeSymbol.class); + assertThat(org.sonar.java.psi.JavaPsiEnvironment.class.getProtectionDomain().getCodeSource().getLocation()) + .isEqualTo(JSema.class.getProtectionDomain().getCodeSource().getLocation()); + assertThat(parsed.tree().sema.getClassType("missing.Unknown").isUnknown()).isTrue(); + assertThat(parsed.tree().sema.getClassType("")).isSameAs(org.sonar.plugins.java.api.semantic.Type.UNKNOWN); + } + } + + private static boolean isCompilerClass(String name) { + return name.contains("org/eclipse/jdt/") && !name.contains("org/eclipse/jdt/annotation/"); + } +} diff --git a/pom.xml b/pom.xml index d3fbff606f2..d8781976466 100644 --- a/pom.xml +++ b/pom.xml @@ -448,6 +448,33 @@ + + org.apache.maven.plugins + maven-enforcer-plugin + + + ban-jdt-compiler + + enforce + + + + + true + + org.sonarsource.java:jdt-package + org.eclipse.jdt:ecj + org.eclipse.jdt:org.eclipse.jdt.core + org.eclipse.jdt.core:* + org.eclipse.jdt.core.compiler:* + + Java source analysis uses PSI. ECJ and JDT core must stay outside the current reactor. + + + + + + de.thetaphi forbiddenapis diff --git a/sonar-java-plugin/pom.xml b/sonar-java-plugin/pom.xml index 496db5b56a7..9466c9eb9fb 100644 --- a/sonar-java-plugin/pom.xml +++ b/sonar-java-plugin/pom.xml @@ -189,7 +189,7 @@ - 65000000 + 52000000 46000000 ${project.build.directory}/${project.build.finalName}.jar @@ -638,6 +638,21 @@ true + + validate-frontend-dependencies + verify + + exec + + + java + + ${project.basedir}/../build-support/FrontendDependencyValidator.java + ${project.build.directory}/${project.build.finalName}.jar + + true + + validate-license-files verify