diff --git a/java-checks-common/pom.xml b/java-checks-common/pom.xml index a5cc848d294..2b72ab227cd 100644 --- a/java-checks-common/pom.xml +++ b/java-checks-common/pom.xml @@ -31,6 +31,11 @@ ${project.version} test + + org.sonarsource.scanner.engine + sensor-test-fixtures + test + commons-io commons-io diff --git a/java-checks-common/src/test/java/org/sonar/java/checks/helpers/JParserTestUtils.java b/java-checks-common/src/test/java/org/sonar/java/checks/helpers/JParserTestUtils.java index 2022a9f4bcb..4b89c3a7115 100644 --- a/java-checks-common/src/test/java/org/sonar/java/checks/helpers/JParserTestUtils.java +++ b/java-checks-common/src/test/java/org/sonar/java/checks/helpers/JParserTestUtils.java @@ -17,12 +17,16 @@ package org.sonar.java.checks.helpers; import com.google.common.io.Files; +import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder; import java.io.File; import java.nio.charset.StandardCharsets; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; -import org.sonar.java.model.JParserConfig; +import org.sonar.java.AnalysisProgress; +import org.sonar.java.model.JParseResult; +import org.sonar.java.model.JParser; import org.sonar.plugins.java.api.JavaVersion; import org.sonar.plugins.java.api.tree.*; @@ -73,8 +77,21 @@ public static CompilationUnitTree parse(File file) { public static CompilationUnitTree parse(String source) { List classpath = Arrays.asList(new File("target/test-classes"), new File("target/classes")); - JavaVersion version = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION; - return JParserConfig.Mode.FILE_BY_FILE.create(version, classpath).parse("test", source); + JavaVersion version = JParser.MAXIMUM_SUPPORTED_JAVA_VERSION; + var inputFile = new TestInputFileBuilder("", "test") + .setContents(source) + .setCharset(StandardCharsets.UTF_8) + .build(); + List results = new ArrayList<>(); + JParser.Mode.FILE_BY_FILE.create(version, classpath) + .parse(List.of(inputFile), () -> false, new AnalysisProgress(1), (input, result) -> results.add(result)); + try { + return results.getFirst().get(); + } catch (RuntimeException e) { + throw e; + } catch (Exception e) { + throw new IllegalStateException("Unable to parse source", e); + } } } diff --git a/java-checks/src/test/java/org/sonar/java/checks/helpers/JParserTestUtils.java b/java-checks/src/test/java/org/sonar/java/checks/helpers/JParserTestUtils.java index 54710f0f970..e61ccd632be 100644 --- a/java-checks/src/test/java/org/sonar/java/checks/helpers/JParserTestUtils.java +++ b/java-checks/src/test/java/org/sonar/java/checks/helpers/JParserTestUtils.java @@ -17,12 +17,16 @@ package org.sonar.java.checks.helpers; import com.google.common.io.Files; +import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder; import java.io.File; import java.nio.charset.StandardCharsets; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; -import org.sonar.java.model.JParserConfig; +import org.sonar.java.AnalysisProgress; +import org.sonar.java.model.JParseResult; +import org.sonar.java.model.JParser; import org.sonar.plugins.java.api.JavaVersion; import org.sonar.plugins.java.api.tree.AssignmentExpressionTree; import org.sonar.plugins.java.api.tree.ClassTree; @@ -83,8 +87,21 @@ public static CompilationUnitTree parse(File file) { public static CompilationUnitTree parse(String source) { List classpath = Arrays.asList(new File("target/test-classes"), new File("target/classes")); - JavaVersion version = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION; - return JParserConfig.Mode.FILE_BY_FILE.create(version, classpath).parse("test", source); + JavaVersion version = JParser.MAXIMUM_SUPPORTED_JAVA_VERSION; + var inputFile = new TestInputFileBuilder("", "test") + .setContents(source) + .setCharset(StandardCharsets.UTF_8) + .build(); + List results = new ArrayList<>(); + JParser.Mode.FILE_BY_FILE.create(version, classpath) + .parse(List.of(inputFile), () -> false, new AnalysisProgress(1), (input, result) -> results.add(result)); + try { + return results.getFirst().get(); + } catch (RuntimeException e) { + throw e; + } catch (Exception e) { + throw new IllegalStateException("Unable to parse source", e); + } } } diff --git a/java-checks/src/test/java/org/sonar/java/checks/helpers/SpringContextModelTestUtils.java b/java-checks/src/test/java/org/sonar/java/checks/helpers/SpringContextModelTestUtils.java index d5336417d7d..435b442a216 100644 --- a/java-checks/src/test/java/org/sonar/java/checks/helpers/SpringContextModelTestUtils.java +++ b/java-checks/src/test/java/org/sonar/java/checks/helpers/SpringContextModelTestUtils.java @@ -22,13 +22,16 @@ import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.function.UnaryOperator; import org.sonar.api.batch.fs.InputFile; +import org.sonar.java.AnalysisProgress; import org.sonar.java.SonarComponents; import org.sonar.java.checks.verifier.TestUtils; -import org.sonar.java.model.JParserConfig; +import org.sonar.java.model.JParseResult; +import org.sonar.java.model.JParser; import org.sonar.java.model.VisitorsBridge; import org.sonar.java.model.springcontext.BeanDefinitionGatherer; import org.sonar.java.model.springcontext.BeanDefinitionHolder; @@ -166,13 +169,16 @@ private static InputFile inputFile(File file) { } private static CompilationUnitTree parse(File file, List classpath) { - String source; + List results = new ArrayList<>(); + JavaVersion version = JParser.MAXIMUM_SUPPORTED_JAVA_VERSION; + JParser.Mode.FILE_BY_FILE.create(version, classpath) + .parse(List.of(inputFile(file)), () -> false, new AnalysisProgress(1), (input, result) -> results.add(result)); try { - source = Files.readString(file.toPath(), StandardCharsets.UTF_8); + return results.getFirst().get(); + } catch (RuntimeException e) { + throw e; } catch (Exception e) { - throw new IllegalStateException("Unable to read file '" + file.getAbsolutePath() + "'", e); + throw new IllegalStateException("Unable to parse file '" + file.getAbsolutePath() + "'", e); } - JavaVersion version = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION; - return JParserConfig.Mode.FILE_BY_FILE.create(version, classpath).parse(file.getName(), source); } } diff --git a/java-frontend/src/main/java/org/sonar/java/JavaFrontend.java b/java-frontend/src/main/java/org/sonar/java/JavaFrontend.java index 809072f92c0..450b1b507dc 100644 --- a/java-frontend/src/main/java/org/sonar/java/JavaFrontend.java +++ b/java-frontend/src/main/java/org/sonar/java/JavaFrontend.java @@ -40,7 +40,8 @@ import org.sonar.java.collections.CollectionUtils; import org.sonar.java.exceptions.ApiMismatchException; import org.sonar.java.filters.SonarJavaIssueFilter; -import org.sonar.java.model.JParserConfig; +import org.sonar.java.model.JParseResult; +import org.sonar.java.model.JParser; import org.sonar.java.model.VisitorsBridge; import org.sonar.java.telemetry.Telemetry; import org.sonar.java.telemetry.TelemetryKey; @@ -237,7 +238,7 @@ private void scanInBatches(BatchModeContext context, List allInputFil private void scanBatch(BatchModeContext context, List batchFiles, AnalysisProgress analysisProgress) { analysisProgress.startBatch(batchFiles.size()); Set environmentsCleaners = new HashSet<>(); - JParserConfig.Mode.BATCH + JParser.Mode.BATCH .create(javaVersion, context.getClasspath(), sonarComponents.shouldIgnoreUnnamedModuleForSplitPackage()) .parse(batchFiles, sonarComponents::analysisCancelled, analysisProgress, (input, result) -> scanAsBatchCallback(input, result, context, environmentsCleaners)); // Due to a bug in ECJ, JAR files remain locked after the analysis on Windows, we unlock them manually, at the end of each batches. See SONARJAVA-3609. @@ -245,7 +246,7 @@ private void scanBatch(BatchModeContext context, List batchFiles, Ana analysisProgress.endBatch(); } - private static void scanAsBatchCallback(InputFile inputFile, JParserConfig.Result result, BatchModeContext context, Set environmentsCleaners) { + private static void scanAsBatchCallback(InputFile inputFile, JParseResult result, BatchModeContext context, Set environmentsCleaners) { JavaAstScanner scanner = context.selectScanner(inputFile); Duration duration = PerformanceMeasure.start(context.descriptor(inputFile)); scanner.simpleScan(inputFile, result, ast -> 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 733e19143fb..91ca8ffca3d 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 @@ -38,7 +38,8 @@ import org.sonar.java.SonarComponents; import org.sonar.java.annotations.VisibleForTesting; import org.sonar.java.model.InputFileUtils; -import org.sonar.java.model.JParserConfig; +import org.sonar.java.model.JParseResult; +import org.sonar.java.model.JParser; import org.sonar.java.model.JavaTree; import org.sonar.java.model.VisitorsBridge; import org.sonar.java.telemetry.NoOpTelemetry; @@ -108,7 +109,7 @@ private void scan(Iterable inputFiles, Consumer cleanUp) { + public void simpleScan(InputFile inputFile, JParseResult result, Consumer cleanUp) { simpleScan(inputFile, result, cleanUp, compilationUnitTree -> {}); } // modifyCompilationUnit should be used for testing. - public void simpleScan(InputFile inputFile, JParserConfig.Result result, Consumer cleanUp, + public void simpleScan(InputFile inputFile, JParseResult result, Consumer cleanUp, Consumer modifyCompilationUnit) { long startTime = currentTimeMillis(); visitor.setCurrentFile(inputFile); diff --git a/java-frontend/src/main/java/org/sonar/java/jdt/JDTAstConverter.java b/java-frontend/src/main/java/org/sonar/java/jdt/JDTAstConverter.java new file mode 100644 index 00000000000..1b1b2de2560 --- /dev/null +++ b/java-frontend/src/main/java/org/sonar/java/jdt/JDTAstConverter.java @@ -0,0 +1,2889 @@ +/* + * 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.jdt; + +import com.sonar.sslr.api.RecognitionException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Deque; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +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.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.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; +import org.sonar.java.ast.parser.ModuleNameListTreeImpl; +import org.sonar.java.ast.parser.ModuleNameTreeImpl; +import org.sonar.java.ast.parser.QualifiedIdentifierListTreeImpl; +import org.sonar.java.ast.parser.ResourceListTreeImpl; +import org.sonar.java.ast.parser.StatementListTreeImpl; +import org.sonar.java.ast.parser.TypeParameterListTreeImpl; +import org.sonar.java.model.AbstractTypedTree; +import org.sonar.java.model.ArrayDimensionTreeImpl; +import org.sonar.java.model.InternalSyntaxToken; +import org.sonar.java.model.InternalSyntaxTrivia; +import org.sonar.java.model.JLabelSymbol; +import org.sonar.java.model.JavaTree; +import org.sonar.java.model.KeywordSuper; +import org.sonar.java.model.KeywordThis; +import org.sonar.java.model.LineColumnConverter; +import org.sonar.java.model.TypeParameterTreeImpl; +import org.sonar.java.model.declaration.AnnotationTreeImpl; +import org.sonar.java.model.declaration.ClassTreeImpl; +import org.sonar.java.model.declaration.EnumConstantTreeImpl; +import org.sonar.java.model.declaration.ExportsDirectiveTreeImpl; +import org.sonar.java.model.declaration.MethodTreeImpl; +import org.sonar.java.model.declaration.ModifierKeywordTreeImpl; +import org.sonar.java.model.declaration.ModifiersTreeImpl; +import org.sonar.java.model.declaration.ModuleDeclarationTreeImpl; +import org.sonar.java.model.declaration.OpensDirectiveTreeImpl; +import org.sonar.java.model.declaration.ProvidesDirectiveTreeImpl; +import org.sonar.java.model.declaration.RequiresDirectiveTreeImpl; +import org.sonar.java.model.declaration.UsesDirectiveTreeImpl; +import org.sonar.java.model.declaration.VariableTreeImpl; +import org.sonar.java.model.expression.ArrayAccessExpressionTreeImpl; +import org.sonar.java.model.expression.AssignmentExpressionTreeImpl; +import org.sonar.java.model.expression.BinaryExpressionTreeImpl; +import org.sonar.java.model.expression.ConditionalExpressionTreeImpl; +import org.sonar.java.model.expression.IdentifierTreeImpl; +import org.sonar.java.model.expression.InstanceOfTreeImpl; +import org.sonar.java.model.expression.InternalPostfixUnaryExpression; +import org.sonar.java.model.expression.InternalPrefixUnaryExpression; +import org.sonar.java.model.expression.LambdaExpressionTreeImpl; +import org.sonar.java.model.expression.LiteralTreeImpl; +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.NewArrayTreeImpl; +import org.sonar.java.model.expression.NewClassTreeImpl; +import org.sonar.java.model.expression.ParenthesizedTreeImpl; +import org.sonar.java.model.expression.TypeArgumentListTreeImpl; +import org.sonar.java.model.expression.TypeCastExpressionTreeImpl; +import org.sonar.java.model.expression.VarTypeTreeImpl; +import org.sonar.java.model.pattern.DefaultPatternTreeImpl; +import org.sonar.java.model.pattern.GuardedPatternTreeImpl; +import org.sonar.java.model.pattern.NullPatternTreeImpl; +import org.sonar.java.model.pattern.RecordPatternTreeImpl; +import org.sonar.java.model.pattern.TypePatternTreeImpl; +import org.sonar.java.model.statement.AssertStatementTreeImpl; +import org.sonar.java.model.statement.BlockTreeImpl; +import org.sonar.java.model.statement.BreakStatementTreeImpl; +import org.sonar.java.model.statement.CaseGroupTreeImpl; +import org.sonar.java.model.statement.CaseLabelTreeImpl; +import org.sonar.java.model.statement.CatchTreeImpl; +import org.sonar.java.model.statement.ContinueStatementTreeImpl; +import org.sonar.java.model.statement.DoWhileStatementTreeImpl; +import org.sonar.java.model.statement.EmptyStatementTreeImpl; +import org.sonar.java.model.statement.ExpressionStatementTreeImpl; +import org.sonar.java.model.statement.ForEachStatementImpl; +import org.sonar.java.model.statement.ForStatementTreeImpl; +import org.sonar.java.model.statement.IfStatementTreeImpl; +import org.sonar.java.model.statement.LabeledStatementTreeImpl; +import org.sonar.java.model.statement.ReturnStatementTreeImpl; +import org.sonar.java.model.statement.StaticInitializerTreeImpl; +import org.sonar.java.model.statement.SwitchExpressionTreeImpl; +import org.sonar.java.model.statement.SwitchStatementTreeImpl; +import org.sonar.java.model.statement.SynchronizedStatementTreeImpl; +import org.sonar.java.model.statement.ThrowStatementTreeImpl; +import org.sonar.java.model.statement.TryStatementTreeImpl; +import org.sonar.java.model.statement.WhileStatementTreeImpl; +import org.sonar.java.model.statement.YieldStatementTreeImpl; +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; +import org.sonar.plugins.java.api.tree.ModuleDirectiveTree; +import org.sonar.plugins.java.api.tree.PackageDeclarationTree; +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.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; + +final class JDTAstConverter { + + private CompilationUnit compilationUnit; + + private TokenManager tokenManager; + private LineColumnConverter lineColumnConverter; + + private JDTSema sema; + + private final Deque labels = new LinkedList<>(); + + static JavaTree.CompilationUnitTreeImpl convert(String version, String unitName, String source, CompilationUnit astNode) { + List errors = Stream.of(astNode.getProblems()).filter(IProblem::isError).toList(); + Optional possibleSyntaxError = errors.stream().filter(JDTProblem::isSyntaxError).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); + } + + JDTAstConverter converter = new JDTAstConverter(); + converter.sema = new JDTSema(astNode.getAST()); + converter.compilationUnit = astNode; + converter.tokenManager = createTokenManager(version, unitName, source); + converter.lineColumnConverter = lineColumnConverter; + + JavaTree.CompilationUnitTreeImpl tree = converter.convertCompilationUnit(astNode); + tree.setSemanticModel(converter.sema, JDTProblem.semanticProblems(errors), ASTUtils.getEnvironmentCleaner(astNode.getAST())); + JDTWarning.Mapper.warningsFor(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; + } + } catch (InvalidInputException e) { + throw new IllegalStateException(e); + } + } + return tokens; + } + + private void declaration(@Nullable IBinding binding, Tree node) { + if (binding == null) { + return; + } + sema.declarations.put(binding, node); + } + + private void usage(@Nullable IBinding binding, IdentifierTree node) { + if (binding == null) { + return; + } + binding = JDTSema.declarationBinding(binding); + sema.usages.computeIfAbsent(binding, k -> new ArrayList<>()).add(node); + } + + private void usageLabel(@Nullable IdentifierTreeImpl node) { + if (node == null) { + return; + } + labels.stream() + .filter(symbol -> symbol.name().equals(node.name())) + .findFirst() + .ifPresent(labelSymbol -> { + labelSymbol.addUsage(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 SyntaxTrivia.CommentKind convertTokenTypeToCommentKind(Token token) { + return switch (token.tokenType) { + case TokenNameCOMMENT_BLOCK -> SyntaxTrivia.CommentKind.BLOCK; + case TokenNameCOMMENT_JAVADOC -> SyntaxTrivia.CommentKind.JAVADOC; + case TokenNameCOMMENT_LINE -> SyntaxTrivia.CommentKind.LINE; + case TokenNameCOMMENT_MARKDOWN -> SyntaxTrivia.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 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 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. + t.setSymbol(sema.importSymbolOrUnknown(e2.resolveBinding())); + } + + imports.add(t); + + int tokenIndex = tokenManager.lastIndexIn(e2, TerminalToken.TokenNameSEMICOLON); + addEmptyStatementsToList(tokenIndex, imports); + } + + List types = new ArrayList<>(); + for (Object type : e.types()) { + processBodyDeclaration((AbstractTypeDeclaration) type, types); + } + + if (e.imports().isEmpty() && e.types().isEmpty()) { + addEmptyStatementsToList(-1, imports); + } + + return new JavaTree.CompilationUnitTreeImpl( + packageDeclaration, + imports, + types, + convertModuleDeclaration(compilationUnit.getModule()), + firstTokenAfter(e, TerminalToken.TokenNameEOF) + ); + } + + 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()); + } + } + + @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 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)); + } + 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(); + } + } + 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)); + } + 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) + ); + } + 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); + + ITypeBinding binding = e.resolveBinding(); + t.setSymbol(sema.typeSymbolOrUnknown(binding)); + declaration(binding, t); + + return t; + } + + 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); + + ITypeBinding binding = e.resolveBinding(); + t.setSymbol(sema.typeSymbolOrUnknown(binding)); + declaration(binding, t); + + return t; + } + + 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)); + } + 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); + } + + 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); + } + return recordComponents; + } + + 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; + } + } + return tokenManager.firstIndexBefore(firstDeclaration, TerminalToken.TokenNameLBRACE); + } + return tokenManager.lastIndexIn(e, TerminalToken.TokenNameLBRACE); + } + + 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 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 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; + } + + 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); + } + classBody = new ClassTreeImpl( + Tree.Kind.CLASS, + firstTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameLBRACE), + members, + lastTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameRBRACE) + ); + ITypeBinding binding = e.getAnonymousClassDeclaration().resolveBinding(); + classBody.setSymbol(sema.typeSymbolOrUnknown(binding)); + declaration(binding, 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(); + } + + IdentifierTreeImpl identifier = createSimpleName(e.getName()); + IMethodBinding constructorBinding; + if (e.getAnonymousClassDeclaration() == null) { + constructorBinding = excludeRecovery(e.resolveConstructorBinding(), arguments.size()); + } else { + constructorBinding = findConstructorForAnonymousClass(e.getAST(), e.getName().resolveTypeBinding(), e.resolveConstructorBinding()); + } + identifier.setSymbol(sema.symbolOrUnknown(constructorBinding)); + usage(constructorBinding, identifier); + + EnumConstantTreeImpl t = new EnumConstantTreeImpl( + convertModifiers(e.modifiers()), + identifier, + new NewClassTreeImpl(identifier, arguments, classBody), + separatorToken + ); + IVariableBinding binding = e.resolveVariable(); + t.setSymbol(sema.variableSymbolOrUnknown(binding)); + declaration(binding, 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()); + } + + 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())); + + IMethodBinding binding = e.resolveBinding(); + t.setSymbol(sema.methodSymbolOrUnknown(binding)); + declaration(binding, 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())); + } + 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); + } + + 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)); + } + 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(), returnType.resolveBinding()), + createSimpleName(e.getName()), + formalParameters, + throwsToken, + thrownExceptionTypes, + body == null ? null : convertBlock(body), + semcolonToken + ).completeWithModifiers( + convertModifiers(e.modifiers()) + ).completeWithTypeParameters( + convertTypeParameters(e.typeParameters()) + ); + IMethodBinding binding = e.resolveBinding(); + t.setSymbol(sema.methodSymbolOrUnknown(binding)); + declaration(binding, 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(), fieldDeclaration.getType().resolveBinding())); + + if (fragment.getInitializer() != null) { + t.completeTypeAndInitializer(t.type(), firstTokenAfter(fragment.getName(), TerminalToken.TokenNameEQUAL), convertExpression(fragment.getInitializer())); + } + + t.setEndToken(firstTokenAfter(fragment, i + 1 < fieldDeclaration.fragments().size() ? TerminalToken.TokenNameCOMMA : TerminalToken.TokenNameSEMICOLON)); + IVariableBinding binding = fragment.resolveBinding(); + t.setSymbol(sema.variableSymbolOrUnknown(binding)); + declaration(binding, t); + + members.add(t); + } + 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)); + } + } + 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)); + } + typeArguments.add(convertType(o)); + } + return typeArguments; + } + + private TypeParameterListTreeImpl convertTypeParameters(List list) { + if (list.isEmpty()) { + return new TypeParameterListTreeImpl(); + } + 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)); + } + t.add(convertTypeParameter(o)); + } + 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)); + } + } + t = new TypeParameterTreeImpl( + i, + firstTokenAfter(e.getName(), TerminalToken.TokenNameextends), + bounds + ); + } + t.setSymbol(sema.symbolOrUnknown(e.resolveBinding())); + return t; + } + + /** + * @param extraDimensions list of {@link org.eclipse.jdt.core.dom.Dimension} + */ + private TypeTree applyExtraDimensions(TypeTree type, List extraDimensions, @Nullable ITypeBinding typeBinding) { + 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) { + ((JavaTree.ArrayTypeTreeImpl) type).setSymbolType(sema.typeOrUnknown(typeBinding.createArrayType(i + 1))); + } + } + return type; + } + + private VariableTreeImpl convertVariable(TypePattern typePattern) { + if (typePattern.getAST().apiLevel() < AST.JLS22) { + return convertVariable(typePattern.getPatternVariable()); + } + VariableDeclaration variableDeclaration = typePattern.getPatternVariable2(); + if (variableDeclaration instanceof VariableDeclarationFragment declarationFragment) { + return convertVariable(declarationFragment); + } else { + return convertVariable((SingleVariableDeclaration) variableDeclaration); + } + } + + private VariableTreeImpl convertVariable(VariableDeclarationFragment declarationFragment) { + return completeInitializerAndBinding( + new VariableTreeImpl(createSimpleName(declarationFragment.getName())), + declarationFragment); + } + + private VariableTreeImpl convertVariable(SingleVariableDeclaration e) { + // TODO are extraDimensions and varargs mutually exclusive? + TypeTree type = convertType(e.getType()); + ITypeBinding typeBinding = e.getType().resolveBinding(); + type = applyExtraDimensions(type, e.extraDimensions(), typeBinding); + if (typeBinding != null && !e.extraDimensions().isEmpty()) { + typeBinding = typeBinding.createArrayType(e.extraDimensions().size()); + } + if (e.isVarargs()) { + type = new JavaTree.ArrayTypeTreeImpl( + type, + (List) convertAnnotations(e.varargsAnnotations()), + firstTokenAfter(e.getType(), TerminalToken.TokenNameELLIPSIS) + ); + if (typeBinding != null) { + ((JavaTree.ArrayTypeTreeImpl) type).setSymbolType(sema.typeOrUnknown(typeBinding.createArrayType(1))); + } + } + + VariableTreeImpl t = new VariableTreeImpl( + convertModifiers(e.modifiers()), + type, + createSimpleName(e.getName()) + ); + return completeInitializerAndBinding(t, e); + } + + private VariableTreeImpl completeInitializerAndBinding(VariableTreeImpl t, VariableDeclaration e) { + if (e.getInitializer() != null) { + t.completeTypeAndInitializer( + t.type(), + firstTokenAfter(e.getName(), TerminalToken.TokenNameEQUAL), + convertExpression(e.getInitializer()) + ); + } + IVariableBinding binding = e.resolveBinding(); + t.setSymbol(sema.variableSymbolOrUnknown(binding)); + if (binding != null) { + if (t.type() instanceof InferedTypeTree inferredType) { + inferredType.setSymbolType(sema.typeOrUnknown(binding.getType())); + } + declaration(binding, t); + } + return t; + } + + private void addVariableToList(VariableDeclarationExpression e2, List list) { + ModifiersTreeImpl modifiers = convertModifiers(e2.modifiers()); + TypeTree type = convertType(e2.getType()); + + 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(), e2.getType().resolveBinding())); + } else { + t.completeTypeAndInitializer( + applyExtraDimensions(type, fragment.extraDimensions(), e2.getType().resolveBinding()), + firstTokenBefore(fragment.getInitializer(), TerminalToken.TokenNameEQUAL), + convertExpression(fragment.getInitializer()) + ); + } + if (i < e2.fragments().size() - 1) { + t.setEndToken(firstTokenAfter(fragment, TerminalToken.TokenNameCOMMA)); + } + IVariableBinding binding = fragment.resolveBinding(); + t.setSymbol(sema.variableSymbolOrUnknown(binding)); + declaration(binding, t); + list.add(t); + } + } + + private VarTypeTreeImpl convertVarType(SimpleType simpleType) { + VarTypeTreeImpl varTree = new VarTypeTreeImpl(firstTokenIn(simpleType.getName(), TerminalToken.TokenNameIdentifier)); + varTree.setSymbolType(sema.typeOrUnknown(simpleType.resolveBinding())); + return varTree; + } + + 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); + t.setSymbolType(sema.typeOrUnknown(e.resolveTypeBinding())); + t.setSymbol(sema.symbolOrUnknown(e.resolveBinding())); + return t; + } + + 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(), e.getType().resolveBinding())) + .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)); + + IVariableBinding binding = fragment.resolveBinding(); + t.setSymbol(sema.variableSymbolOrUnknown(binding)); + declaration(binding, t); + statements.add(t); + } + } 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)); + } + if (ASTNode.VARIABLE_DECLARATION_EXPRESSION == o.getNodeType()) { + addVariableToList((VariableDeclarationExpression) o, forInitStatement); + } else { + forInitStatement.add(new ExpressionStatementTreeImpl(convertExpression(o), null)); + } + } + + 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(); + } + + List expressions = ((List) c.expressions()).stream() + .map(Expression.class::cast) + .map(this::convertExpressionFromCase) + .toList(); + + 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.typeOrUnknown(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.typeOrUnknown(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.typeOrUnknown(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); + + LabeledStatementTreeImpl t = new LabeledStatementTreeImpl( + i, + firstTokenAfter(e.getLabel(), TerminalToken.TokenNameCOLON), + createStatement(e.getBody()) + ); + + labels.pop(); + symbol.setDeclaration(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); + } + return resources; + } + + 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; + } + separators.add(createSyntaxToken(tokenIndex)); + } + } + } + + 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 + ); + IMethodBinding binding = e.resolveConstructorBinding(); + if (binding != null) { + t.setSymbolType(sema.typeOrUnknown(binding.getDeclaringClass())); + binding = excludeRecovery(binding, arguments.size()); + } + t.setMethodSymbol(sema.methodSymbolOrUnknown(binding)); + i.setSymbol(sema.symbolOrUnknown(binding)); + usage(binding, 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 + ); + IMethodBinding binding = e.resolveConstructorBinding(); + if (binding != null) { + t.setSymbolType(sema.typeOrUnknown(binding.getDeclaringClass())); + binding = excludeRecovery(binding, arguments.size()); + } + t.setMethodSymbol(sema.methodSymbolOrUnknown(binding)); + i.setSymbol(sema.symbolOrUnknown(binding)); + usage(binding, 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); + ((AbstractTypedTree) t).setSymbolType(sema.typeOrUnknown(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(e.resolveBinding(), t); + return t; + } + + private MemberSelectExpressionTreeImpl convertQualifiedName(QualifiedName e) { + IdentifierTreeImpl rhs = createSimpleName(e.getName()); + usage(e.getName().resolveBinding(), rhs); + return new MemberSelectExpressionTreeImpl( + convertExpression(e.getQualifier()), + firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), + rhs + ); + } + + private MemberSelectExpressionTreeImpl convertFieldAccess(FieldAccess e) { + IdentifierTreeImpl rhs = createSimpleName(e.getName()); + usage(e.getName().resolveBinding(), rhs); + return new MemberSelectExpressionTreeImpl( + convertExpression(e.getExpression()), + firstTokenAfter(e.getExpression(), TerminalToken.TokenNameDOT), + rhs + ); + } + + private MemberSelectExpressionTreeImpl convertFieldAccess(SuperFieldAccess e) { + IdentifierTreeImpl rhs = createSimpleName(e.getName()); + usage(e.getName().resolveBinding(), 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()); + ITypeBinding qualifierBinding = e.getQualifier().resolveTypeBinding(); + KeywordSuper keywordSuper = new KeywordSuper(firstTokenAfter(e.getQualifier(), TerminalToken.TokenNamesuper), sema.superSymbolOrUnknown(qualifierBinding)); + MemberSelectExpressionTreeImpl qualifiedSuper = new MemberSelectExpressionTreeImpl( + (ExpressionTree) qualifier, + firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), + keywordSuper + ); + if (qualifierBinding != null) { + qualifiedSuper.setSymbolType(sema.typeOrUnknown(qualifierBinding.getSuperclass())); + } + return new MemberSelectExpressionTreeImpl( + qualifiedSuper, + firstTokenBefore(e.getName(), TerminalToken.TokenNameDOT), + rhs + ); + } + + private ExpressionTree convertThisExpression(ThisExpression e) { + if (e.getQualifier() == null) { + return new KeywordThis(firstTokenIn(e, TerminalToken.TokenNamethis), sema.thisSymbolOrUnknown(e.resolveTypeBinding())); + } + KeywordThis keywordThis = new KeywordThis( + firstTokenAfter(e.getQualifier(), TerminalToken.TokenNamethis), + sema.thisSymbolOrUnknown(e.resolveTypeBinding()) + ); + keywordThis.setSymbolType(sema.typeOrUnknown(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(); + } + + 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()); + } + index--; + type = ((ArrayTypeTree) type).type(); + } + + return new NewArrayTreeImpl(dimensions, initializers) + .complete(type) + .completeWithNewKeyword(firstTokenIn(e, TerminalToken.TokenNamenew)); + } + + 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)); + } + } + 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); + } + classBody = new ClassTreeImpl( + Tree.Kind.CLASS, + firstTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameLBRACE), + members, + lastTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameRBRACE) + ); + ITypeBinding binding = e.getAnonymousClassDeclaration().resolveBinding(); + classBody.setSymbol(sema.typeSymbolOrUnknown(binding)); + declaration(binding, 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(); + IMethodBinding binding; + if (e.getAnonymousClassDeclaration() == null) { + binding = excludeRecovery(e.resolveConstructorBinding(), nbArguments); + } else { + Type constructorType = e.getType() instanceof ParameterizedType parameterizedType ? parameterizedType.getType() : e.getType(); + binding = excludeRecovery(findConstructorForAnonymousClass(e.getAST(), constructorType.resolveBinding(), e.resolveConstructorBinding()), nbArguments); + } + i.setSymbol(sema.symbolOrUnknown(binding)); + usage(binding, 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; + t.setSymbolType(sema.typeOrUnknown(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 + ); + IMethodBinding binding = excludeRecovery(e.resolveMethodBinding(), arguments.size()); + t.setMethodSymbol(sema.methodSymbolOrUnknown(binding)); + rhs.setSymbol(sema.symbolOrUnknown(binding)); + usage(binding, 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()); + ITypeBinding qualifierBinding = e.getQualifier().resolveTypeBinding(); + KeywordSuper keywordSuper = new KeywordSuper(firstTokenAfter(e.getQualifier(), TerminalToken.TokenNamesuper), sema.superSymbolOrUnknown(qualifierBinding)); + MemberSelectExpressionTreeImpl qualifiedSuper = new MemberSelectExpressionTreeImpl( + (ExpressionTree) qualifier, + createSyntaxToken(firstDotTokenIndex), + keywordSuper + ); + if (qualifierBinding != null) { + qualifiedSuper.setSymbolType(sema.typeOrUnknown(qualifierBinding.getSuperclass())); + } + outermostSelect = new MemberSelectExpressionTreeImpl( + qualifiedSuper, + createSyntaxToken(nextTokenIndex(firstDotTokenIndex, TerminalToken.TokenNameDOT)), + rhs + ); + } + + MethodInvocationTreeImpl t = new MethodInvocationTreeImpl( + outermostSelect, + null, + arguments + ); + IMethodBinding binding = excludeRecovery(e.resolveMethodBinding(), arguments.size()); + t.setMethodSymbol(sema.methodSymbolOrUnknown(binding)); + rhs.setSymbol(sema.symbolOrUnknown(binding)); + usage(binding, 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) + ); + } + + private InternalPrefixUnaryExpression convertPrefixExpression(PrefixExpression e) { + Op op = operators.get(e.getOperator()); + return new InternalPrefixUnaryExpression( + op.kind, + firstTokenIn(e, op.tokenType), + convertExpression(e.getOperand()) + ); + } + + 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 InstanceOfTreeImpl convertInstanceOf(PatternInstanceofExpression e) { + Expression leftOperand = e.getLeftOperand(); + InternalSyntaxToken instanceofToken = firstTokenAfter(leftOperand, TerminalToken.TokenNameinstanceof); + return new InstanceOfTreeImpl(convertExpression(leftOperand), instanceofToken, convertPattern(e.getPattern())); + } + + 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) { + t.setSymbol(sema.variableSymbolOrUnknown(variableBinding)); + ((InferedTypeTree) t.type()).setSymbolType(sema.typeOrUnknown(variableBinding.getType())); + declaration(variableBinding, t); + } + } else { + t = convertVariable((SingleVariableDeclaration) o); + } + parameters.add(t); + if (i < e.parameters().size() - 1) { + t.setEndToken(firstTokenAfter(o, TerminalToken.TokenNameCOMMA)); + } + } + 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) + ); + tree.setSymbol(sema.methodSymbolOrUnknown(e.resolveMethodBinding())); + return tree; + } + + 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)); + IMethodBinding binding = e.resolveMethodBinding(); + i.setSymbol(sema.symbolOrUnknown(binding)); + usage(binding, 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(e.getName().resolveBinding(), 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(e.getName().resolveBinding(), 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(e.getName().resolveBinding(), 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(); + } + ((LiteralTreeImpl) result).setSymbolType(sema.typeOrUnknown(e.resolveTypeBinding())); + if (unaryMinus) { + return new InternalPrefixUnaryExpression(Tree.Kind.UNARY_MINUS, createSyntaxToken(tokenIndex - 1), result); + } + return result; + } + + private LiteralTreeImpl convertLiteral(CharacterLiteral e) { + return new LiteralTreeImpl(Tree.Kind.CHAR_LITERAL, firstTokenIn(e, TerminalToken.TokenNameCharacterLiteral)); + } + + private LiteralTreeImpl convertLiteral(BooleanLiteral e) { + InternalSyntaxToken value = firstTokenIn(e, e.booleanValue() ? TerminalToken.TokenNametrue : TerminalToken.TokenNamefalse); + return new LiteralTreeImpl(Tree.Kind.BOOLEAN_LITERAL, value); + } + + private LiteralTreeImpl convertLiteral(StringLiteral e) { + return new LiteralTreeImpl(Tree.Kind.STRING_LITERAL, firstTokenIn(e, TerminalToken.TokenNameStringLiteral)); + } + + private LiteralTreeImpl convertTextBlock(TextBlock e) { + return new LiteralTreeImpl(Tree.Kind.TEXT_BLOCK, firstTokenIn(e, TerminalToken.TokenNameTextBlock)); + } + + 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 new KeywordSuper(token, sema.superSymbolOrUnknown(abstractTypeDeclaration.resolveBinding())); + } + if (node instanceof AnonymousClassDeclaration anonymousClassDeclaration) { + return new KeywordSuper(token, sema.superSymbolOrUnknown(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)); + break; + default: + throw new IllegalStateException(e.getPrimitiveTypeCode().toString()); + } + t.complete(convertAnnotations(e.annotations())); + t.setSymbolType(sema.typeOrUnknown(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); + t.setSymbolType(sema.typeOrUnknown(e.resolveBinding())); + return t; + } + + 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) { + ((JavaTree.ArrayTypeTreeImpl) t).setSymbolType(sema.typeOrUnknown(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 + ) + ) + ); + t.setSymbolType(sema.typeOrUnknown(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())); + t.setSymbolType(sema.typeOrUnknown(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())); + t.setSymbolType(sema.typeOrUnknown(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); + } + t.complete(convertAnnotations(e.annotations())); + t.setSymbolType(sema.typeOrUnknown(e.resolveBinding())); + return t; + } + + @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; + } + } else { + if (arguments != methodBinding.getParameterTypes().length) { + return null; + } + } + return methodBinding; + } + + @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)); + } + + +} diff --git a/java-frontend/src/main/java/org/sonar/java/jdt/JDTParser.java b/java-frontend/src/main/java/org/sonar/java/jdt/JDTParser.java index 0d5fa3f2165..e90d55e591f 100644 --- a/java-frontend/src/main/java/org/sonar/java/jdt/JDTParser.java +++ b/java-frontend/src/main/java/org/sonar/java/jdt/JDTParser.java @@ -17,2910 +17,240 @@ package org.sonar.java.jdt; import com.sonar.sslr.api.RecognitionException; +import java.io.File; import java.util.ArrayList; -import java.util.Collections; -import java.util.Deque; +import java.util.Arrays; import java.util.HashMap; -import java.util.Iterator; -import java.util.LinkedList; +import java.util.HashSet; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; -import java.util.Objects; -import java.util.Optional; -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 java.util.Set; +import java.util.concurrent.TimeUnit; +import java.util.function.BiConsumer; +import java.util.function.BooleanSupplier; +import java.util.stream.StreamSupport; +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.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.eclipse.jdt.core.dom.FileASTRequestor; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.sonar.api.batch.fs.InputFile; +import org.sonar.java.AnalysisException; +import org.sonar.java.AnalysisProgress; +import org.sonar.java.ExecutionTimeReport; 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; -import org.sonar.java.ast.parser.ModuleNameListTreeImpl; -import org.sonar.java.ast.parser.ModuleNameTreeImpl; -import org.sonar.java.ast.parser.QualifiedIdentifierListTreeImpl; -import org.sonar.java.ast.parser.ResourceListTreeImpl; -import org.sonar.java.ast.parser.StatementListTreeImpl; -import org.sonar.java.ast.parser.TypeParameterListTreeImpl; -import org.sonar.java.model.AbstractTypedTree; -import org.sonar.java.model.ArrayDimensionTreeImpl; -import org.sonar.java.model.InternalSyntaxToken; -import org.sonar.java.model.InternalSyntaxTrivia; -import org.sonar.java.model.JLabelSymbol; +import org.sonar.java.model.JParseResult; import org.sonar.java.model.JParser; import org.sonar.java.model.JavaTree; -import org.sonar.java.model.KeywordSuper; -import org.sonar.java.model.KeywordThis; -import org.sonar.java.model.LineColumnConverter; -import org.sonar.java.model.TypeParameterTreeImpl; -import org.sonar.java.model.declaration.AnnotationTreeImpl; -import org.sonar.java.model.declaration.ClassTreeImpl; -import org.sonar.java.model.declaration.EnumConstantTreeImpl; -import org.sonar.java.model.declaration.ExportsDirectiveTreeImpl; -import org.sonar.java.model.declaration.MethodTreeImpl; -import org.sonar.java.model.declaration.ModifierKeywordTreeImpl; -import org.sonar.java.model.declaration.ModifiersTreeImpl; -import org.sonar.java.model.declaration.ModuleDeclarationTreeImpl; -import org.sonar.java.model.declaration.OpensDirectiveTreeImpl; -import org.sonar.java.model.declaration.ProvidesDirectiveTreeImpl; -import org.sonar.java.model.declaration.RequiresDirectiveTreeImpl; -import org.sonar.java.model.declaration.UsesDirectiveTreeImpl; -import org.sonar.java.model.declaration.VariableTreeImpl; -import org.sonar.java.model.expression.ArrayAccessExpressionTreeImpl; -import org.sonar.java.model.expression.AssignmentExpressionTreeImpl; -import org.sonar.java.model.expression.BinaryExpressionTreeImpl; -import org.sonar.java.model.expression.ConditionalExpressionTreeImpl; -import org.sonar.java.model.expression.IdentifierTreeImpl; -import org.sonar.java.model.expression.InstanceOfTreeImpl; -import org.sonar.java.model.expression.InternalPostfixUnaryExpression; -import org.sonar.java.model.expression.InternalPrefixUnaryExpression; -import org.sonar.java.model.expression.LambdaExpressionTreeImpl; -import org.sonar.java.model.expression.LiteralTreeImpl; -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.NewArrayTreeImpl; -import org.sonar.java.model.expression.NewClassTreeImpl; -import org.sonar.java.model.expression.ParenthesizedTreeImpl; -import org.sonar.java.model.expression.TypeArgumentListTreeImpl; -import org.sonar.java.model.expression.TypeCastExpressionTreeImpl; -import org.sonar.java.model.expression.VarTypeTreeImpl; -import org.sonar.java.model.pattern.DefaultPatternTreeImpl; -import org.sonar.java.model.pattern.GuardedPatternTreeImpl; -import org.sonar.java.model.pattern.NullPatternTreeImpl; -import org.sonar.java.model.pattern.RecordPatternTreeImpl; -import org.sonar.java.model.pattern.TypePatternTreeImpl; -import org.sonar.java.model.statement.AssertStatementTreeImpl; -import org.sonar.java.model.statement.BlockTreeImpl; -import org.sonar.java.model.statement.BreakStatementTreeImpl; -import org.sonar.java.model.statement.CaseGroupTreeImpl; -import org.sonar.java.model.statement.CaseLabelTreeImpl; -import org.sonar.java.model.statement.CatchTreeImpl; -import org.sonar.java.model.statement.ContinueStatementTreeImpl; -import org.sonar.java.model.statement.DoWhileStatementTreeImpl; -import org.sonar.java.model.statement.EmptyStatementTreeImpl; -import org.sonar.java.model.statement.ExpressionStatementTreeImpl; -import org.sonar.java.model.statement.ForEachStatementImpl; -import org.sonar.java.model.statement.ForStatementTreeImpl; -import org.sonar.java.model.statement.IfStatementTreeImpl; -import org.sonar.java.model.statement.LabeledStatementTreeImpl; -import org.sonar.java.model.statement.ReturnStatementTreeImpl; -import org.sonar.java.model.statement.StaticInitializerTreeImpl; -import org.sonar.java.model.statement.SwitchExpressionTreeImpl; -import org.sonar.java.model.statement.SwitchStatementTreeImpl; -import org.sonar.java.model.statement.SynchronizedStatementTreeImpl; -import org.sonar.java.model.statement.ThrowStatementTreeImpl; -import org.sonar.java.model.statement.TryStatementTreeImpl; -import org.sonar.java.model.statement.WhileStatementTreeImpl; -import org.sonar.java.model.statement.YieldStatementTreeImpl; -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; -import org.sonar.plugins.java.api.tree.ModuleDirectiveTree; -import org.sonar.plugins.java.api.tree.PackageDeclarationTree; -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 org.sonar.plugins.java.api.JavaVersion; +import org.sonarsource.analyzer.commons.ProgressReport; +import org.sonarsource.performance.measure.PerformanceMeasure; -@SuppressWarnings({"rawtypes", "unchecked"}) -final class JDTParser implements JParser { +public abstract class JDTParser implements JParser { private static final Logger LOG = LoggerFactory.getLogger(JDTParser.class); + private static final String MAXIMUM_ECJ_WARNINGS = "42000"; + private static final Set JRE_JARS = new HashSet<>(Arrays.asList("rt.jar", "jrt-fs.jar", "android.jar")); - private final ASTParser parser; + final JavaVersion javaVersion; + final List classpath; + final boolean shouldIgnoreUnnamedModuleForSplitPackage; - JDTParser(ASTParser parser) { - this.parser = parser; - } - - @Override - public JavaTree.CompilationUnitTreeImpl parse(String version, String unitName, String source) { - return parse(parser, version, unitName, source); - } - - /** - * @param unitName see {@link ASTParser#setUnitName(String)} - * @throws RecognitionException in case of syntax errors - */ - static JavaTree.CompilationUnitTreeImpl parse(ASTParser astParser, String version, String unitName, String source) { - 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); - } - - return convert(astParser, version, unitName, source, astNode); - } - - static JavaTree.CompilationUnitTreeImpl convert(ASTParser astParser, String version, String unitName, String source, CompilationUnit astNode) { - List errors = Stream.of(astNode.getProblems()).filter(IProblem::isError).toList(); - Optional possibleSyntaxError = errors.stream().filter(JDTProblem::isSyntaxError).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); - } - - JDTParser converter = new JDTParser(astParser); - converter.sema = new JDTSema(astNode.getAST()); - converter.compilationUnit = astNode; - converter.tokenManager = createTokenManager(version, unitName, source); - converter.lineColumnConverter = lineColumnConverter; - - JavaTree.CompilationUnitTreeImpl tree = converter.convertCompilationUnit(astNode); - tree.setSemanticModel(converter.sema, JDTProblem.semanticProblems(errors), ASTUtils.getEnvironmentCleaner(astNode.getAST())); - JDTWarning.Mapper.warningsFor(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(); + public static JParser create(JParser.Mode mode, JavaVersion javaVersion, List classpath, boolean shouldIgnoreUnnamedModuleForSplitPackage) { + if (shouldIgnoreUnnamedModuleForSplitPackage) { + LOG.info("The Java analyzer will ignore the unnamed module for split packages."); } - return ((JavaTree) node).getChildren().iterator(); + return switch (mode) { + case BATCH -> new Batch(javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); + case FILE_BY_FILE -> new FileByFile(javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); + }; } @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; - } - } catch (InvalidInputException e) { - throw new IllegalStateException(e); - } - } - return tokens; - } - - private CompilationUnit compilationUnit; - - private TokenManager tokenManager; - private LineColumnConverter lineColumnConverter; - - private JDTSema sema; - - private final Deque labels = new LinkedList<>(); - - private void declaration(@Nullable IBinding binding, Tree node) { - if (binding == null) { - return; - } - sema.declarations.put(binding, node); + static boolean shouldEnablePreviewFlag(JavaVersion currentVersion) { + return currentVersion.arePreviewFeaturesEnabled(); } - private void usage(@Nullable IBinding binding, IdentifierTree node) { - if (binding == null) { - return; - } - binding = JDTSema.declarationBinding(binding); - sema.usages.computeIfAbsent(binding, k -> new ArrayList<>()).add(node); + private JDTParser(JavaVersion javaVersion, List classpath, boolean shouldIgnoreUnnamedModuleForSplitPackage) { + this.javaVersion = javaVersion; + this.classpath = classpath; + this.shouldIgnoreUnnamedModuleForSplitPackage = shouldIgnoreUnnamedModuleForSplitPackage; } - private void usageLabel(@Nullable IdentifierTreeImpl node) { - if (node == null) { - return; + protected ASTParser jdtAstParser() { + ASTParser astParser = ASTParser.newParser(AST.getJLSLatest()); + Map options = new HashMap<>(JavaCore.getOptions()); + JavaCore.setComplianceOptions(javaVersion.effectiveJavaVersionAsString(), options); + options.put(JavaCore.COMPILER_PB_MAX_PER_UNIT, MAXIMUM_ECJ_WARNINGS); + if (shouldIgnoreUnnamedModuleForSplitPackage) { + options.put(JavaCore.COMPILER_IGNORE_UNNAMED_MODULE_FOR_SPLIT_PACKAGE, "enabled"); } - labels.stream() - .filter(symbol -> symbol.name().equals(node.name())) - .findFirst() - .ifPresent(labelSymbol -> { - labelSymbol.addUsage(node); - node.labelSymbol = labelSymbol; - }); - } - - private int firstTokenIndexAfter(ASTNode e) { - int index = tokenManager.firstIndexAfter(e, ANY_TOKEN); - while (isComment(tokenManager.get(index))) { - index++; + if (shouldEnablePreviewFlag(javaVersion)) { + options.put(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, "enabled"); } - 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())); - } + // enabling all supported compiler warnings + JDTProblem.compilerOptions() + .forEach(option -> options.put(option, "warning")); - /** - * @param tokenType {@link TerminalToken} - */ - private InternalSyntaxToken lastTokenIn(ASTNode e, TerminalToken tokenType) { - return createSyntaxToken(tokenManager.lastIndexIn(e, tokenType)); - } + astParser.setCompilerOptions(options); - 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); - } + boolean includeRunningVMBootclasspath = classpath.stream() + .noneMatch(f -> JRE_JARS.contains(f.getName())); - 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); - } + astParser.setEnvironment(classpath.stream() + .map(File::getAbsolutePath) + .toArray(String[]::new), new String[]{}, new String[]{}, includeRunningVMBootclasspath); - 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(); - } + astParser.setResolveBindings(true); + astParser.setBindingsRecovery(true); - @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); - }; + return astParser; } - /** - * {@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 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))); - } - } + static class Batch extends JDTParser { - 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) - ); + Batch(JavaVersion javaVersion, List classpath, boolean shouldIgnoreUnnamedModuleForSplitPackage) { + super(javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); } - 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. - t.setSymbol(sema.importSymbolOrUnknown(e2.resolveBinding())); - } - - imports.add(t); - - int tokenIndex = tokenManager.lastIndexIn(e2, TerminalToken.TokenNameSEMICOLON); - addEmptyStatementsToList(tokenIndex, imports); - } - - List types = new ArrayList<>(); - for (Object type : e.types()) { - processBodyDeclaration((AbstractTypeDeclaration) type, types); - } - - if (e.imports().isEmpty() && e.types().isEmpty()) { - addEmptyStatementsToList(-1, imports); - } - - return new JavaTree.CompilationUnitTreeImpl( - packageDeclaration, - imports, - types, - convertModuleDeclaration(compilationUnit.getModule()), - firstTokenAfter(e, TerminalToken.TokenNameEOF) - ); - } - - 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()); - } - } - - @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 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)); + @Override + public void parse(Iterable inputFiles, BooleanSupplier isCanceled, AnalysisProgress analysisProgress, BiConsumer action) { + List sourceFilePaths = new ArrayList<>(); + Set notYetAnalyzedFiles = new LinkedHashSet<>(); + List encodings = new ArrayList<>(); + Map inputs = new HashMap<>(); + for (InputFile inputFile : inputFiles) { + String sourceFilePath = inputFile.absolutePath(); + inputs.put(new File(sourceFilePath), inputFile); + sourceFilePaths.add(sourceFilePath); + encodings.add(inputFile.charset().name()); + notYetAnalyzedFiles.add(inputFile); } - 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(); + ExecutionTimeReport executionTimeReport = new ExecutionTimeReport(); + ProgressMonitor monitor = new ProgressMonitor(isCanceled, analysisProgress); + PerformanceMeasure.Duration batchPerformance = PerformanceMeasure.start("ParseAsBatch"); + try { + ASTParser astParser = jdtAstParser(); + astParser.createASTs(sourceFilePaths.toArray(new String[0]), encodings.toArray(new String[0]), new String[0], new FileASTRequestor() { + @Override + public void acceptAST(String sourceFilePath, CompilationUnit ast) { + PerformanceMeasure.Duration convertDuration = PerformanceMeasure.start("Convert"); + InputFile inputFile = inputs.get(new File(sourceFilePath)); + executionTimeReport.start(inputFile); + JParseResult result; + try { + result = JParseResult.success(JDTAstConverter.convert(javaVersion.effectiveJavaVersionAsString(), inputFile.filename(), inputFile.contents(), ast)); + } catch (Exception e) { + result = JParseResult.failure(e); + } + convertDuration.stop(); + PerformanceMeasure.Duration analyzeDuration = PerformanceMeasure.start("Analyze"); + action.accept(inputFile, result); + + notYetAnalyzedFiles.remove(inputFile); + executionTimeReport.end(); + analyzeDuration.stop(); } + }, monitor); + if (!notYetAnalyzedFiles.isEmpty()) { + String message = String.format("%d/%d files were not analyzed by the batch mode", notYetAnalyzedFiles.size(), sourceFilePaths.size()); + throw new AnalysisException(message); } - 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)); - } - typeNames.add((TypeTree) convertExpression(o)); + } catch (OperationCanceledException e) { + throw e; + } catch (RuntimeException e) { + LOG.warn("Unexpected {}: {}", e.getClass().getSimpleName(), e.getMessage()); + if (!notYetAnalyzedFiles.isEmpty()) { + fallbackToFileByFileMode(notYetAnalyzedFiles.stream().toList(), isCanceled, analysisProgress, action); } - return new ProvidesDirectiveTreeImpl( - firstTokenIn(e, TerminalToken.TokenNameprovides), - (TypeTree) convertExpression(e.getName()), - firstTokenAfter(e.getName(), TerminalToken.TokenNamewith), - typeNames, - lastTokenIn(e, TerminalToken.TokenNameSEMICOLON) - ); + } finally { + batchPerformance.stop(); + // ExecutionTimeReport will not include the parsing time by file when using batch mode. + executionTimeReport.reportAsBatch(); + monitor.done(); } - 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); - - ITypeBinding binding = e.resolveBinding(); - t.setSymbol(sema.typeSymbolOrUnknown(binding)); - declaration(binding, t); - - return t; - } - - 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()); + private void fallbackToFileByFileMode(List inputFiles, BooleanSupplier isCanceled, AnalysisProgress analysisProgress, BiConsumer action) { + LOG.warn("Fallback to file by file analysis for {} files", inputFiles.size()); + FileByFile fileByFile = new FileByFile(javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); + fileByFile.parse(inputFiles, isCanceled, analysisProgress, action); } - - // no-op for annotation-types - completeSuperInterfaces(e, t); - - ITypeBinding binding = e.resolveBinding(); - t.setSymbol(sema.typeSymbolOrUnknown(binding)); - declaration(binding, t); - - return t; } - 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); - } + private static class FileByFile extends JDTParser { - if (!e.isInterface() && e.getSuperclassType() != null) { - Type superclassType = e.getSuperclassType(); - t.completeSuperclass(firstTokenBefore(superclassType, TerminalToken.TokenNameextends), convertType(superclassType)); + private FileByFile(JavaVersion javaVersion, List classpath, boolean shouldIgnoreUnnamedModuleForSplitPackage) { + super(javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); } - 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); - } - - 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); - } - return recordComponents; - } + @Override + public void parse(Iterable inputFiles, BooleanSupplier isCanceled, AnalysisProgress analysisProgress, BiConsumer action) { + boolean successfullyCompleted = false; + boolean cancelled = false; - 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; + ExecutionTimeReport executionTimeReport = new ExecutionTimeReport(); + ProgressReport progressReport = new ProgressReport("Report about progress of Java AST analyzer", TimeUnit.SECONDS.toMillis(10)); + List filesNames = StreamSupport.stream(inputFiles.spliterator(), false) + .map(InputFile::toString) + .toList(); + progressReport.start(filesNames); + try { + for (InputFile inputFile : inputFiles) { + if (isCanceled.getAsBoolean()) { + cancelled = true; + break; + } + executionTimeReport.start(inputFile); + parse(inputFile, javaVersion, action); + executionTimeReport.end(); + progressReport.nextFile(); } - } - return tokenManager.firstIndexBefore(firstDeclaration, TerminalToken.TokenNameLBRACE); - } - return tokenManager.lastIndexIn(e, TerminalToken.TokenNameLBRACE); - } - - 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 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 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; - } - - 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); - } - classBody = new ClassTreeImpl( - Tree.Kind.CLASS, - firstTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameLBRACE), - members, - lastTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameRBRACE) - ); - ITypeBinding binding = e.getAnonymousClassDeclaration().resolveBinding(); - classBody.setSymbol(sema.typeSymbolOrUnknown(binding)); - declaration(binding, 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(); - } - - IdentifierTreeImpl identifier = createSimpleName(e.getName()); - IMethodBinding constructorBinding; - if (e.getAnonymousClassDeclaration() == null) { - constructorBinding = excludeRecovery(e.resolveConstructorBinding(), arguments.size()); - } else { - constructorBinding = findConstructorForAnonymousClass(e.getAST(), e.getName().resolveTypeBinding(), e.resolveConstructorBinding()); - } - identifier.setSymbol(sema.symbolOrUnknown(constructorBinding)); - usage(constructorBinding, identifier); - - EnumConstantTreeImpl t = new EnumConstantTreeImpl( - convertModifiers(e.modifiers()), - identifier, - new NewClassTreeImpl(identifier, arguments, classBody), - separatorToken - ); - IVariableBinding binding = e.resolveVariable(); - t.setSymbol(sema.variableSymbolOrUnknown(binding)); - declaration(binding, 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()); - } - - 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())); - - IMethodBinding binding = e.resolveBinding(); - t.setSymbol(sema.methodSymbolOrUnknown(binding)); - declaration(binding, 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())); - } - 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); - } - - 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)); - } - 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(), returnType.resolveBinding()), - createSimpleName(e.getName()), - formalParameters, - throwsToken, - thrownExceptionTypes, - body == null ? null : convertBlock(body), - semcolonToken - ).completeWithModifiers( - convertModifiers(e.modifiers()) - ).completeWithTypeParameters( - convertTypeParameters(e.typeParameters()) - ); - IMethodBinding binding = e.resolveBinding(); - t.setSymbol(sema.methodSymbolOrUnknown(binding)); - declaration(binding, 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(), fieldDeclaration.getType().resolveBinding())); - - if (fragment.getInitializer() != null) { - t.completeTypeAndInitializer(t.type(), firstTokenAfter(fragment.getName(), TerminalToken.TokenNameEQUAL), convertExpression(fragment.getInitializer())); - } - - t.setEndToken(firstTokenAfter(fragment, i + 1 < fieldDeclaration.fragments().size() ? TerminalToken.TokenNameCOMMA : TerminalToken.TokenNameSEMICOLON)); - IVariableBinding binding = fragment.resolveBinding(); - t.setSymbol(sema.variableSymbolOrUnknown(binding)); - declaration(binding, t); - - members.add(t); - } - 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)); - } - } - 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)); - } - typeArguments.add(convertType(o)); - } - return typeArguments; - } - - private TypeParameterListTreeImpl convertTypeParameters(List list) { - if (list.isEmpty()) { - return new TypeParameterListTreeImpl(); - } - 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)); - } - t.add(convertTypeParameter(o)); - } - 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)); + successfullyCompleted = !cancelled; + } finally { + if (successfullyCompleted) { + progressReport.stop(); + } else { + progressReport.cancel(); } + executionTimeReport.report(); } - t = new TypeParameterTreeImpl( - i, - firstTokenAfter(e.getName(), TerminalToken.TokenNameextends), - bounds - ); - } - t.setSymbol(sema.symbolOrUnknown(e.resolveBinding())); - return t; - } - - /** - * @param extraDimensions list of {@link org.eclipse.jdt.core.dom.Dimension} - */ - private TypeTree applyExtraDimensions(TypeTree type, List extraDimensions, @Nullable ITypeBinding typeBinding) { - 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) { - ((JavaTree.ArrayTypeTreeImpl) type).setSymbolType(sema.typeOrUnknown(typeBinding.createArrayType(i + 1))); - } - } - return type; - } - - private VariableTreeImpl convertVariable(TypePattern typePattern) { - if (typePattern.getAST().apiLevel() < AST.JLS22) { - return convertVariable(typePattern.getPatternVariable()); - } - VariableDeclaration variableDeclaration = typePattern.getPatternVariable2(); - if (variableDeclaration instanceof VariableDeclarationFragment declarationFragment) { - return convertVariable(declarationFragment); - } else { - return convertVariable((SingleVariableDeclaration) variableDeclaration); - } - } - - private VariableTreeImpl convertVariable(VariableDeclarationFragment declarationFragment) { - return completeInitializerAndBinding( - new VariableTreeImpl(createSimpleName(declarationFragment.getName())), - declarationFragment); - } - - private VariableTreeImpl convertVariable(SingleVariableDeclaration e) { - // TODO are extraDimensions and varargs mutually exclusive? - TypeTree type = convertType(e.getType()); - ITypeBinding typeBinding = e.getType().resolveBinding(); - type = applyExtraDimensions(type, e.extraDimensions(), typeBinding); - if (typeBinding != null && !e.extraDimensions().isEmpty()) { - typeBinding = typeBinding.createArrayType(e.extraDimensions().size()); - } - if (e.isVarargs()) { - type = new JavaTree.ArrayTypeTreeImpl( - type, - (List) convertAnnotations(e.varargsAnnotations()), - firstTokenAfter(e.getType(), TerminalToken.TokenNameELLIPSIS) - ); - if (typeBinding != null) { - ((JavaTree.ArrayTypeTreeImpl) type).setSymbolType(sema.typeOrUnknown(typeBinding.createArrayType(1))); - } - } - - VariableTreeImpl t = new VariableTreeImpl( - convertModifiers(e.modifiers()), - type, - createSimpleName(e.getName()) - ); - return completeInitializerAndBinding(t, e); - } - - private VariableTreeImpl completeInitializerAndBinding(VariableTreeImpl t, VariableDeclaration e) { - if (e.getInitializer() != null) { - t.completeTypeAndInitializer( - t.type(), - firstTokenAfter(e.getName(), TerminalToken.TokenNameEQUAL), - convertExpression(e.getInitializer()) - ); - } - IVariableBinding binding = e.resolveBinding(); - t.setSymbol(sema.variableSymbolOrUnknown(binding)); - if (binding != null) { - if (t.type() instanceof InferedTypeTree inferredType) { - inferredType.setSymbolType(sema.typeOrUnknown(binding.getType())); - } - declaration(binding, t); } - return t; - } - private void addVariableToList(VariableDeclarationExpression e2, List list) { - ModifiersTreeImpl modifiers = convertModifiers(e2.modifiers()); - TypeTree type = convertType(e2.getType()); - - 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(), e2.getType().resolveBinding())); - } else { - t.completeTypeAndInitializer( - applyExtraDimensions(type, fragment.extraDimensions(), e2.getType().resolveBinding()), - firstTokenBefore(fragment.getInitializer(), TerminalToken.TokenNameEQUAL), - convertExpression(fragment.getInitializer()) - ); - } - if (i < e2.fragments().size() - 1) { - t.setEndToken(firstTokenAfter(fragment, TerminalToken.TokenNameCOMMA)); + private void parse(InputFile inputFile, JavaVersion javaVersion, BiConsumer action) { + JParseResult result; + PerformanceMeasure.Duration parseDuration = PerformanceMeasure.start("JParser"); + try { + result = JParseResult.success(parse(javaVersion.effectiveJavaVersionAsString(), inputFile.filename(), inputFile.contents())); + } catch (Exception e) { + result = JParseResult.failure(e); + } finally { + parseDuration.stop(); } - IVariableBinding binding = fragment.resolveBinding(); - t.setSymbol(sema.variableSymbolOrUnknown(binding)); - declaration(binding, t); - list.add(t); - } - } - - private VarTypeTreeImpl convertVarType(SimpleType simpleType) { - VarTypeTreeImpl varTree = new VarTypeTreeImpl(firstTokenIn(simpleType.getName(), TerminalToken.TokenNameIdentifier)); - varTree.setSymbolType(sema.typeOrUnknown(simpleType.resolveBinding())); - return varTree; - } - - 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); - t.setSymbolType(sema.typeOrUnknown(e.resolveTypeBinding())); - t.setSymbol(sema.symbolOrUnknown(e.resolveBinding())); - return t; - } - - private BlockTreeImpl convertBlock(Block e) { - List statements = new ArrayList<>(); - for (Object o : e.statements()) { - addStatementToList((Statement) o, statements); + action.accept(inputFile, result); } - 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(), e.getType().resolveBinding())) - .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)); + private JavaTree.CompilationUnitTreeImpl parse(String version, String unitName, String source) { + ASTParser parser = jdtAstParser(); + parser.setUnitName(unitName); + parser.setSource(source.toCharArray()); - IVariableBinding binding = fragment.resolveBinding(); - t.setSymbol(sema.variableSymbolOrUnknown(binding)); - declaration(binding, t); - statements.add(t); + CompilationUnit astNode; + try { + astNode = (CompilationUnit) parser.createAST(null); + } catch (Exception e) { + LOG.error("ECJ: Unable to parse file", e); + throw new RecognitionException(-1, "ECJ: Unable to parse file.", e); } - } 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()); + return JDTAstConverter.convert(version, unitName, source, astNode); } } - 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)); - } - if (ASTNode.VARIABLE_DECLARATION_EXPRESSION == o.getNodeType()) { - addVariableToList((VariableDeclarationExpression) o, forInitStatement); - } else { - forInitStatement.add(new ExpressionStatementTreeImpl(convertExpression(o), null)); - } - } - - 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(); - } - - List expressions = ((List) c.expressions()).stream() - .map(Expression.class::cast) - .map(this::convertExpressionFromCase) - .toList(); - - 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.typeOrUnknown(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.typeOrUnknown(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.typeOrUnknown(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); - - LabeledStatementTreeImpl t = new LabeledStatementTreeImpl( - i, - firstTokenAfter(e.getLabel(), TerminalToken.TokenNameCOLON), - createStatement(e.getBody()) - ); - - labels.pop(); - symbol.setDeclaration(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); - } - return resources; - } - - 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; - } - separators.add(createSyntaxToken(tokenIndex)); - } - } - } - - 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 - ); - IMethodBinding binding = e.resolveConstructorBinding(); - if (binding != null) { - t.setSymbolType(sema.typeOrUnknown(binding.getDeclaringClass())); - binding = excludeRecovery(binding, arguments.size()); - } - t.setMethodSymbol(sema.methodSymbolOrUnknown(binding)); - i.setSymbol(sema.symbolOrUnknown(binding)); - usage(binding, 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 - ); - IMethodBinding binding = e.resolveConstructorBinding(); - if (binding != null) { - t.setSymbolType(sema.typeOrUnknown(binding.getDeclaringClass())); - binding = excludeRecovery(binding, arguments.size()); - } - t.setMethodSymbol(sema.methodSymbolOrUnknown(binding)); - i.setSymbol(sema.symbolOrUnknown(binding)); - usage(binding, 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); - ((AbstractTypedTree) t).setSymbolType(sema.typeOrUnknown(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(e.resolveBinding(), t); - return t; - } - - private MemberSelectExpressionTreeImpl convertQualifiedName(QualifiedName e) { - IdentifierTreeImpl rhs = createSimpleName(e.getName()); - usage(e.getName().resolveBinding(), rhs); - return new MemberSelectExpressionTreeImpl( - convertExpression(e.getQualifier()), - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), - rhs - ); - } - - private MemberSelectExpressionTreeImpl convertFieldAccess(FieldAccess e) { - IdentifierTreeImpl rhs = createSimpleName(e.getName()); - usage(e.getName().resolveBinding(), rhs); - return new MemberSelectExpressionTreeImpl( - convertExpression(e.getExpression()), - firstTokenAfter(e.getExpression(), TerminalToken.TokenNameDOT), - rhs - ); - } - - private MemberSelectExpressionTreeImpl convertFieldAccess(SuperFieldAccess e) { - IdentifierTreeImpl rhs = createSimpleName(e.getName()); - usage(e.getName().resolveBinding(), 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()); - ITypeBinding qualifierBinding = e.getQualifier().resolveTypeBinding(); - KeywordSuper keywordSuper = new KeywordSuper(firstTokenAfter(e.getQualifier(), TerminalToken.TokenNamesuper), sema.superSymbolOrUnknown(qualifierBinding)); - MemberSelectExpressionTreeImpl qualifiedSuper = new MemberSelectExpressionTreeImpl( - (ExpressionTree) qualifier, - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNameDOT), - keywordSuper - ); - if (qualifierBinding != null) { - qualifiedSuper.setSymbolType(sema.typeOrUnknown(qualifierBinding.getSuperclass())); - } - return new MemberSelectExpressionTreeImpl( - qualifiedSuper, - firstTokenBefore(e.getName(), TerminalToken.TokenNameDOT), - rhs - ); - } - - private ExpressionTree convertThisExpression(ThisExpression e) { - if (e.getQualifier() == null) { - return new KeywordThis(firstTokenIn(e, TerminalToken.TokenNamethis), sema.thisSymbolOrUnknown(e.resolveTypeBinding())); - } - KeywordThis keywordThis = new KeywordThis( - firstTokenAfter(e.getQualifier(), TerminalToken.TokenNamethis), - sema.thisSymbolOrUnknown(e.resolveTypeBinding()) - ); - keywordThis.setSymbolType(sema.typeOrUnknown(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(); - } - - 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()); - } - index--; - type = ((ArrayTypeTree) type).type(); - } - - return new NewArrayTreeImpl(dimensions, initializers) - .complete(type) - .completeWithNewKeyword(firstTokenIn(e, TerminalToken.TokenNamenew)); - } - - 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)); - } - } - 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); - } - classBody = new ClassTreeImpl( - Tree.Kind.CLASS, - firstTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameLBRACE), - members, - lastTokenIn(e.getAnonymousClassDeclaration(), TerminalToken.TokenNameRBRACE) - ); - ITypeBinding binding = e.getAnonymousClassDeclaration().resolveBinding(); - classBody.setSymbol(sema.typeSymbolOrUnknown(binding)); - declaration(binding, 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(); - IMethodBinding binding; - if (e.getAnonymousClassDeclaration() == null) { - binding = excludeRecovery(e.resolveConstructorBinding(), nbArguments); - } else { - Type constructorType = e.getType() instanceof ParameterizedType parameterizedType ? parameterizedType.getType() : e.getType(); - binding = excludeRecovery(findConstructorForAnonymousClass(e.getAST(), constructorType.resolveBinding(), e.resolveConstructorBinding()), nbArguments); - } - i.setSymbol(sema.symbolOrUnknown(binding)); - usage(binding, 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; - t.setSymbolType(sema.typeOrUnknown(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 - ); - IMethodBinding binding = excludeRecovery(e.resolveMethodBinding(), arguments.size()); - t.setMethodSymbol(sema.methodSymbolOrUnknown(binding)); - rhs.setSymbol(sema.symbolOrUnknown(binding)); - usage(binding, 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()); - ITypeBinding qualifierBinding = e.getQualifier().resolveTypeBinding(); - KeywordSuper keywordSuper = new KeywordSuper(firstTokenAfter(e.getQualifier(), TerminalToken.TokenNamesuper), sema.superSymbolOrUnknown(qualifierBinding)); - MemberSelectExpressionTreeImpl qualifiedSuper = new MemberSelectExpressionTreeImpl( - (ExpressionTree) qualifier, - createSyntaxToken(firstDotTokenIndex), - keywordSuper - ); - if (qualifierBinding != null) { - qualifiedSuper.setSymbolType(sema.typeOrUnknown(qualifierBinding.getSuperclass())); - } - outermostSelect = new MemberSelectExpressionTreeImpl( - qualifiedSuper, - createSyntaxToken(nextTokenIndex(firstDotTokenIndex, TerminalToken.TokenNameDOT)), - rhs - ); - } - - MethodInvocationTreeImpl t = new MethodInvocationTreeImpl( - outermostSelect, - null, - arguments - ); - IMethodBinding binding = excludeRecovery(e.resolveMethodBinding(), arguments.size()); - t.setMethodSymbol(sema.methodSymbolOrUnknown(binding)); - rhs.setSymbol(sema.symbolOrUnknown(binding)); - usage(binding, 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) - ); - } - - private InternalPrefixUnaryExpression convertPrefixExpression(PrefixExpression e) { - Op op = operators.get(e.getOperator()); - return new InternalPrefixUnaryExpression( - op.kind, - firstTokenIn(e, op.tokenType), - convertExpression(e.getOperand()) - ); - } - - 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 InstanceOfTreeImpl convertInstanceOf(PatternInstanceofExpression e) { - Expression leftOperand = e.getLeftOperand(); - InternalSyntaxToken instanceofToken = firstTokenAfter(leftOperand, TerminalToken.TokenNameinstanceof); - return new InstanceOfTreeImpl(convertExpression(leftOperand), instanceofToken, convertPattern(e.getPattern())); - } - - 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) { - t.setSymbol(sema.variableSymbolOrUnknown(variableBinding)); - ((InferedTypeTree) t.type()).setSymbolType(sema.typeOrUnknown(variableBinding.getType())); - declaration(variableBinding, t); - } - } else { - t = convertVariable((SingleVariableDeclaration) o); - } - parameters.add(t); - if (i < e.parameters().size() - 1) { - t.setEndToken(firstTokenAfter(o, TerminalToken.TokenNameCOMMA)); - } - } - 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) - ); - tree.setSymbol(sema.methodSymbolOrUnknown(e.resolveMethodBinding())); - return tree; - } - - 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)); - IMethodBinding binding = e.resolveMethodBinding(); - i.setSymbol(sema.symbolOrUnknown(binding)); - usage(binding, 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(e.getName().resolveBinding(), 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(e.getName().resolveBinding(), 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(e.getName().resolveBinding(), 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(); - } - ((LiteralTreeImpl) result).setSymbolType(sema.typeOrUnknown(e.resolveTypeBinding())); - if (unaryMinus) { - return new InternalPrefixUnaryExpression(Tree.Kind.UNARY_MINUS, createSyntaxToken(tokenIndex - 1), result); - } - return result; - } - - private LiteralTreeImpl convertLiteral(CharacterLiteral e) { - return new LiteralTreeImpl(Tree.Kind.CHAR_LITERAL, firstTokenIn(e, TerminalToken.TokenNameCharacterLiteral)); - } - - private LiteralTreeImpl convertLiteral(BooleanLiteral e) { - InternalSyntaxToken value = firstTokenIn(e, e.booleanValue() ? TerminalToken.TokenNametrue : TerminalToken.TokenNamefalse); - return new LiteralTreeImpl(Tree.Kind.BOOLEAN_LITERAL, value); - } - - private LiteralTreeImpl convertLiteral(StringLiteral e) { - return new LiteralTreeImpl(Tree.Kind.STRING_LITERAL, firstTokenIn(e, TerminalToken.TokenNameStringLiteral)); - } - - private LiteralTreeImpl convertTextBlock(TextBlock e) { - return new LiteralTreeImpl(Tree.Kind.TEXT_BLOCK, firstTokenIn(e, TerminalToken.TokenNameTextBlock)); - } - - 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 new KeywordSuper(token, sema.superSymbolOrUnknown(abstractTypeDeclaration.resolveBinding())); - } - if (node instanceof AnonymousClassDeclaration anonymousClassDeclaration) { - return new KeywordSuper(token, sema.superSymbolOrUnknown(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)); - break; - default: - throw new IllegalStateException(e.getPrimitiveTypeCode().toString()); - } - t.complete(convertAnnotations(e.annotations())); - t.setSymbolType(sema.typeOrUnknown(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); - t.setSymbolType(sema.typeOrUnknown(e.resolveBinding())); - return t; - } - - 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) { - ((JavaTree.ArrayTypeTreeImpl) t).setSymbolType(sema.typeOrUnknown(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 - ) - ) - ); - t.setSymbolType(sema.typeOrUnknown(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())); - t.setSymbolType(sema.typeOrUnknown(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())); - t.setSymbolType(sema.typeOrUnknown(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); - } - t.complete(convertAnnotations(e.annotations())); - t.setSymbolType(sema.typeOrUnknown(e.resolveBinding())); - return t; - } - - @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; - } - } else { - if (arguments != methodBinding.getParameterTypes().length) { - return null; - } - } - return methodBinding; - } - - @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)); - } - } diff --git a/java-frontend/src/main/java/org/sonar/java/jdt/JDTParserConfig.java b/java-frontend/src/main/java/org/sonar/java/jdt/JDTParserConfig.java deleted file mode 100644 index d9874b00ca9..00000000000 --- a/java-frontend/src/main/java/org/sonar/java/jdt/JDTParserConfig.java +++ /dev/null @@ -1,259 +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.jdt; - -import java.io.File; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.HashSet; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.TimeUnit; -import java.util.function.BiConsumer; -import java.util.function.BooleanSupplier; -import java.util.stream.StreamSupport; -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.core.dom.FileASTRequestor; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.sonar.api.batch.fs.InputFile; -import org.sonar.java.AnalysisException; -import org.sonar.java.AnalysisProgress; -import org.sonar.java.ExecutionTimeReport; -import org.sonar.java.annotations.VisibleForTesting; -import org.sonar.java.model.JParser; -import org.sonar.java.model.JParserConfig; -import org.sonar.java.model.JavaTree; -import org.sonar.plugins.java.api.JavaVersion; -import org.sonarsource.analyzer.commons.ProgressReport; -import org.sonarsource.performance.measure.PerformanceMeasure; - -public abstract class JDTParserConfig implements JParserConfig { - - private static final Logger LOG = LoggerFactory.getLogger(JDTParserConfig.class); - - private static final String MAXIMUM_ECJ_WARNINGS = "42000"; - private static final Set JRE_JARS = new HashSet<>(Arrays.asList("rt.jar", "jrt-fs.jar", "android.jar")); - - final JavaVersion javaVersion; - final List classpath; - final boolean shouldIgnoreUnnamedModuleForSplitPackage; - - private JDTParserConfig(JavaVersion javaVersion, List classpath, boolean shouldIgnoreUnnamedModuleForSplitPackage) { - this.javaVersion = javaVersion; - this.classpath = classpath; - this.shouldIgnoreUnnamedModuleForSplitPackage = shouldIgnoreUnnamedModuleForSplitPackage; - } - - public static JParserConfig create(JParserConfig.Mode mode, JavaVersion javaVersion, List classpath, - boolean shouldIgnoreUnnamedModuleForSplitPackage) { - if (shouldIgnoreUnnamedModuleForSplitPackage) { - LOG.info("The Java analyzer will ignore the unnamed module for split packages."); - } - return switch (mode) { - case BATCH -> new Batch(javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); - case FILE_BY_FILE -> new FileByFile(javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); - }; - } - - @Override - public JavaTree.CompilationUnitTreeImpl parse(String unitName, String source) { - return astParser().parse(javaVersion.effectiveJavaVersionAsString(), unitName, source); - } - - @Override - public JParser astParser() { - return new JDTParser(jdtParser()); - } - - ASTParser jdtParser() { - ASTParser astParser = ASTParser.newParser(AST.getJLSLatest()); - Map options = new HashMap<>(JavaCore.getOptions()); - JavaCore.setComplianceOptions(javaVersion.effectiveJavaVersionAsString(), options); - options.put(JavaCore.COMPILER_PB_MAX_PER_UNIT, MAXIMUM_ECJ_WARNINGS); - if (shouldIgnoreUnnamedModuleForSplitPackage) { - options.put(JavaCore.COMPILER_IGNORE_UNNAMED_MODULE_FOR_SPLIT_PACKAGE, "enabled"); - } - if (shouldEnablePreviewFlag(javaVersion)) { - options.put(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, "enabled"); - } - // enabling all supported compiler warnings - JDTProblem.compilerOptions() - .forEach(option -> options.put(option, "warning")); - - astParser.setCompilerOptions(options); - - boolean includeRunningVMBootclasspath = classpath.stream() - .noneMatch(f -> JRE_JARS.contains(f.getName())); - - astParser.setEnvironment(classpath.stream() - .map(File::getAbsolutePath) - .toArray(String[]::new), new String[] {}, new String[] {}, includeRunningVMBootclasspath); - - astParser.setResolveBindings(true); - astParser.setBindingsRecovery(true); - - return astParser; - } - - @VisibleForTesting - static class Batch extends JDTParserConfig { - - Batch(JavaVersion javaVersion, List classpath, boolean shouldIgnoreUnnamedModuleForSplitPackage) { - super(javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); - } - - @Override - public void parse(Iterable inputFiles, BooleanSupplier isCanceled, - AnalysisProgress analysisProgress, BiConsumer action) { - - List sourceFilePaths = new ArrayList<>(); - Set notYetAnalyzedFiles = new LinkedHashSet<>(); - List encodings = new ArrayList<>(); - Map inputs = new HashMap<>(); - for (InputFile inputFile : inputFiles) { - String sourceFilePath = inputFile.absolutePath(); - inputs.put(new File(sourceFilePath), inputFile); - sourceFilePaths.add(sourceFilePath); - encodings.add(inputFile.charset().name()); - notYetAnalyzedFiles.add(inputFile); - } - - ExecutionTimeReport executionTimeReport = new ExecutionTimeReport(); - ProgressMonitor monitor = new ProgressMonitor(isCanceled, analysisProgress); - PerformanceMeasure.Duration batchPerformance = PerformanceMeasure.start("ParseAsBatch"); - try { - ASTParser astParser = jdtParser(); - astParser.createASTs(sourceFilePaths.toArray(new String[0]), encodings.toArray(new String[0]), new String[0], new FileASTRequestor() { - @Override - public void acceptAST(String sourceFilePath, CompilationUnit ast) { - PerformanceMeasure.Duration convertDuration = PerformanceMeasure.start("Convert"); - InputFile inputFile = inputs.get(new File(sourceFilePath)); - executionTimeReport.start(inputFile); - Result result; - try { - result = Result.success(JDTParser.convert(astParser, javaVersion.effectiveJavaVersionAsString(), inputFile.filename(), inputFile.contents(), ast)); - } catch (Exception e) { - result = Result.failure(e); - } - convertDuration.stop(); - PerformanceMeasure.Duration analyzeDuration = PerformanceMeasure.start("Analyze"); - action.accept(inputFile, result); - - notYetAnalyzedFiles.remove(inputFile); - executionTimeReport.end(); - analyzeDuration.stop(); - } - }, monitor); - if (!notYetAnalyzedFiles.isEmpty()) { - String message = String.format("%d/%d files were not analyzed by the batch mode", notYetAnalyzedFiles.size(), sourceFilePaths.size()); - throw new AnalysisException(message); - } - } catch (OperationCanceledException e) { - throw e; - } catch (RuntimeException e) { - LOG.warn("Unexpected {}: {}", e.getClass().getSimpleName(), e.getMessage()); - if (!notYetAnalyzedFiles.isEmpty()) { - fallbackToFileByFileMode(notYetAnalyzedFiles.stream().toList(), isCanceled, action); - } - } finally { - batchPerformance.stop(); - // ExecutionTimeReport will not include the parsing time by file when using batch mode. - executionTimeReport.reportAsBatch(); - monitor.done(); - } - } - - 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 (isCanceled.getAsBoolean()) { - break; - } - FileByFile.parse(jdtParser(), inputFile, javaVersion, action); - } - } - - } - - private static class FileByFile extends JDTParserConfig { - - private FileByFile(JavaVersion javaVersion, List classpath, boolean shouldIgnoreUnnamedModuleForSplitPackage) { - super(javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); - } - - @Override - public void parse(Iterable inputFiles, BooleanSupplier isCanceled, - AnalysisProgress analysisProgress, BiConsumer action) { - boolean successfullyCompleted = false; - boolean cancelled = false; - - ExecutionTimeReport executionTimeReport = new ExecutionTimeReport(); - ProgressReport progressReport = new ProgressReport("Report about progress of Java AST analyzer", TimeUnit.SECONDS.toMillis(10)); - List filesNames = StreamSupport.stream(inputFiles.spliterator(), false) - .map(InputFile::toString) - .toList(); - progressReport.start(filesNames); - try { - for (InputFile inputFile : inputFiles) { - if (isCanceled.getAsBoolean()) { - cancelled = true; - break; - } - executionTimeReport.start(inputFile); - parse(jdtParser(), inputFile, javaVersion, action); - executionTimeReport.end(); - progressReport.nextFile(); - } - successfullyCompleted = !cancelled; - } finally { - if (successfullyCompleted) { - progressReport.stop(); - } else { - progressReport.cancel(); - } - executionTimeReport.report(); - } - } - - private static void parse(ASTParser astParser, InputFile inputFile, JavaVersion javaVersion, BiConsumer action) { - Result result; - PerformanceMeasure.Duration parseDuration = PerformanceMeasure.start("JParser"); - try { - result = Result.success(JDTParser.parse(astParser, javaVersion.effectiveJavaVersionAsString(), inputFile.filename(), inputFile.contents())); - } catch (Exception e) { - result = Result.failure(e); - } finally { - parseDuration.stop(); - } - action.accept(inputFile, result); - } - } - - @VisibleForTesting - static boolean shouldEnablePreviewFlag(JavaVersion currentVersion) { - return currentVersion.arePreviewFeaturesEnabled(); - } - -} diff --git a/java-frontend/src/main/java/org/sonar/java/model/JParseResult.java b/java-frontend/src/main/java/org/sonar/java/model/JParseResult.java new file mode 100644 index 00000000000..f455c20754a --- /dev/null +++ b/java-frontend/src/main/java/org/sonar/java/model/JParseResult.java @@ -0,0 +1,46 @@ +/* + * 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 javax.annotation.Nullable; + +public final class JParseResult { + + private final Exception exception; + private final JavaTree.CompilationUnitTreeImpl tree; + + private JParseResult(@Nullable Exception exception, @Nullable JavaTree.CompilationUnitTreeImpl tree) { + this.exception = exception; + this.tree = tree; + } + + public static JParseResult success(JavaTree.CompilationUnitTreeImpl tree) { + return new JParseResult(null, tree); + } + + public static JParseResult failure(Exception exception) { + return new JParseResult(exception, null); + } + + public JavaTree.CompilationUnitTreeImpl get() throws Exception { + if (exception != null) { + throw exception; + } + return tree; + } + +} 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 02dd10b3c52..6e1f1af0dd4 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,12 +16,32 @@ */ package org.sonar.java.model; +import java.io.File; +import java.util.List; +import java.util.function.BiConsumer; +import java.util.function.BooleanSupplier; +import org.sonar.api.batch.fs.InputFile; +import org.sonar.java.AnalysisProgress; +import org.sonar.java.jdt.JDTParser; +import org.sonar.plugins.java.api.JavaVersion; + public interface JParser { - JavaTree.CompilationUnitTreeImpl parse(String version, String unitName, String source); + JavaVersion MAXIMUM_SUPPORTED_JAVA_VERSION = new JavaVersionImpl(JavaVersionImpl.MAX_SUPPORTED, true); + + enum Mode { + BATCH, + FILE_BY_FILE; - static JavaTree.CompilationUnitTreeImpl parse(JParser parser, String version, String unitName, String source) { - return parser.parse(version, unitName, source); + public JParser create(JavaVersion javaVersion, List classpath) { + return create(javaVersion, classpath, false); + } + + public JParser create(JavaVersion javaVersion, List classpath, boolean shouldIgnoreUnnamedModuleForSplitPackage) { + return JDTParser.create(this, javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); + } } + void parse(Iterable inputFiles, BooleanSupplier isCanceled, AnalysisProgress analysisProgress, BiConsumer action); + } 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 deleted file mode 100644 index f3d0a4eb6ec..00000000000 --- a/java-frontend/src/main/java/org/sonar/java/model/JParserConfig.java +++ /dev/null @@ -1,83 +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.List; -import java.util.function.BiConsumer; -import java.util.function.BooleanSupplier; -import javax.annotation.Nullable; -import org.sonar.api.batch.fs.InputFile; -import org.sonar.java.AnalysisProgress; -import org.sonar.java.jdt.JDTParserConfig; -import org.sonar.plugins.java.api.JavaVersion; - -public interface JParserConfig { - - JavaVersion MAXIMUM_SUPPORTED_JAVA_VERSION = new JavaVersionImpl(JavaVersionImpl.MAX_SUPPORTED, true); - - JParser astParser(); - - JavaTree.CompilationUnitTreeImpl parse(String unitName, String source); - - void parse(Iterable inputFiles, BooleanSupplier isCanceled, - AnalysisProgress analysisProgress, BiConsumer action); - - enum Mode { - BATCH, - FILE_BY_FILE; - - public JParserConfig create(JavaVersion javaVersion, List classpath) { - return create(javaVersion, classpath, false); - } - - public JParserConfig create(JavaVersion javaVersion, List classpath, boolean shouldIgnoreUnnamedModuleForSplitPackage) { - return JDTParserConfig.create(this, javaVersion, classpath, shouldIgnoreUnnamedModuleForSplitPackage); - } - } - - final class Result { - private final Exception exception; - private final JavaTree.CompilationUnitTreeImpl tree; - - private Result(@Nullable Exception exception, @Nullable JavaTree.CompilationUnitTreeImpl tree) { - this.exception = exception; - this.tree = tree; - } - - public static Result success(JavaTree.CompilationUnitTreeImpl tree) { - return new Result(null, tree); - } - - public static Result failure(Exception exception) { - return new Result(exception, null); - } - - public JavaTree.CompilationUnitTreeImpl get() throws Exception { - if (exception != null) { - throw exception; - } - return tree; - } - } - - @FunctionalInterface - interface ParserConfigConstructor { - JParserConfig apply(JavaVersion version, List files, Boolean shouldIgnoreUnnamedModuleForSplitPackage); - } - -} 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 7566a61a793..94d958a04e4 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 @@ -47,7 +47,7 @@ import org.sonar.java.classpath.ClasspathForMain; import org.sonar.java.classpath.ClasspathForTest; import org.sonar.java.exceptions.ApiMismatchException; -import org.sonar.java.model.JParserConfig; +import org.sonar.java.model.JParseResult; import org.sonar.java.model.JParserTestUtils; import org.sonar.java.model.JavaTree; import org.sonar.java.model.JavaVersionImpl; @@ -402,7 +402,7 @@ void skippableVisitors_are_not_used_when_file_is_unchanged() throws ApiMismatchE jas.setVisitorBridge(visitorsBridge); InputFile inputFile = new TestInputFileBuilder("class A {}", "file.java").build(); - jas.simpleScan(inputFile, mock(JParserConfig.Result.class), ignored -> {}); + jas.simpleScan(inputFile, mock(JParseResult.class), ignored -> {}); verify(skippable, never()).visitNode(any()); verify(unskippable, times(1)).visitNode(any()); diff --git a/java-frontend/src/test/java/org/sonar/java/ast/visitors/SyntaxHighlighterVisitorTest.java b/java-frontend/src/test/java/org/sonar/java/ast/visitors/SyntaxHighlighterVisitorTest.java index e84c1197f94..543a2499d36 100644 --- a/java-frontend/src/test/java/org/sonar/java/ast/visitors/SyntaxHighlighterVisitorTest.java +++ b/java-frontend/src/test/java/org/sonar/java/ast/visitors/SyntaxHighlighterVisitorTest.java @@ -38,7 +38,7 @@ import org.sonar.java.TestUtils; import org.sonar.java.classpath.ClasspathForMain; import org.sonar.java.classpath.ClasspathForTest; -import org.sonar.java.model.JParserConfig; +import org.sonar.java.model.JParser; import org.sonar.java.telemetry.NoOpTelemetry; import org.sonar.plugins.java.api.JavaVersion; @@ -253,7 +253,7 @@ void sealed_classes() { } private void scan(InputFile inputFile) { - JavaVersion javaVersion = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION; + JavaVersion javaVersion = JParser.MAXIMUM_SUPPORTED_JAVA_VERSION; JavaFrontend frontend = new JavaFrontend(javaVersion, mockSonarComponents(), mock(Measurer.class), new NoOpTelemetry(), null, null, syntaxHighlighterVisitor); frontend.scan(Collections.singletonList(inputFile), Collections.emptyList(), Collections.emptyList()); } diff --git a/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserConfigTest.java b/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserConfigTest.java deleted file mode 100644 index d3457d0c9b5..00000000000 --- a/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserConfigTest.java +++ /dev/null @@ -1,43 +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.jdt; - -import org.junit.jupiter.api.Test; -import org.sonar.java.model.JavaVersionImpl; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.sonar.java.jdt.JDTParserConfig.shouldEnablePreviewFlag; - -class JDTParserConfigTest { - - @Test - void should_enable_preview() { - assertThat(shouldEnablePreviewFlag(new JavaVersionImpl())).isFalse(); - assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(8))).isFalse(); - assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(11))).isFalse(); - assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(16))).isFalse(); - assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(17))).isFalse(); - assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(18))).isFalse(); - assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(19))).isFalse(); - assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(20))).isFalse(); - assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(42))).isFalse(); - assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(42, true))).isTrue(); - - assertThat(shouldEnablePreviewFlag(JavaVersionImpl.fromString("1.8"))).isFalse(); - assertThat(shouldEnablePreviewFlag(JavaVersionImpl.fromString("1.8", "True"))).isTrue(); - } -} diff --git a/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserSemanticTest.java b/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserSemanticTest.java index a53588dd5ab..d81611854e9 100644 --- a/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserSemanticTest.java +++ b/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserSemanticTest.java @@ -27,7 +27,7 @@ import org.eclipse.jdt.core.dom.SwitchStatement; import org.eclipse.jdt.core.dom.TypeDeclaration; import org.junit.jupiter.api.Test; -import org.sonar.java.model.JParserConfig; +import org.sonar.java.model.JParser; import org.sonar.plugins.java.api.JavaVersion; import static org.assertj.core.api.Assertions.assertThat; @@ -46,7 +46,7 @@ void not_need_to_skip_implicit_break_statement() { } private CompilationUnit createAST(String source) { - JavaVersion version = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION; + JavaVersion version = JParser.MAXIMUM_SUPPORTED_JAVA_VERSION; ASTParser astParser = ASTParser.newParser(AST.getJLSLatest()); Map options = new HashMap<>(JavaCore.getOptions()); JavaCore.setComplianceOptions(version.effectiveJavaVersionAsString(), options); diff --git a/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserTest.java b/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserTest.java index 022fcf6d6b4..9f43a98afdb 100644 --- a/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserTest.java +++ b/java-frontend/src/test/java/org/sonar/java/jdt/JDTParserTest.java @@ -16,6 +16,8 @@ */ package org.sonar.java.jdt; +import java.nio.file.Files; +import java.nio.file.Path; import java.util.ArrayList; import java.util.Arrays; import java.util.Deque; @@ -33,26 +35,31 @@ 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; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; import org.slf4j.event.Level; import org.sonar.api.batch.fs.InputFile; import org.sonar.java.AnalysisProgress; import org.sonar.java.TestUtils; -import org.sonar.java.model.JParserConfig; -import org.sonar.java.model.JParserConfig.Result; +import org.sonar.java.model.JParseResult; +import org.sonar.java.model.JParser; import org.sonar.java.model.JavaTree; +import org.sonar.java.model.JavaVersionImpl; import org.sonar.java.testing.ThreadLocalLogTester; import org.sonar.plugins.java.api.tree.ClassTree; import org.sonar.plugins.java.api.tree.SyntaxTrivia.CommentKind; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.when; -import static org.sonar.java.jdt.JDTParser.convertTokenTypeToCommentKind; -import static org.sonar.java.jdt.JDTParser.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.jdt.JDTAstConverter.convertTokenTypeToCommentKind; +import static org.sonar.java.jdt.JDTAstConverter.isComment; +import static org.sonar.java.jdt.JDTParser.shouldEnablePreviewFlag; +import static org.sonar.java.model.JParser.MAXIMUM_SUPPORTED_JAVA_VERSION; +import static org.sonar.java.model.JParser.Mode.BATCH; import static org.sonar.java.model.JParserTestUtils.DEFAULT_CLASSPATH; class JDTParserTest { @@ -62,7 +69,7 @@ class JDTParserTest { @Test void test_first_index_of_tokens_in_eclipse_ast() { - String version = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION.effectiveJavaVersionAsString(); + String version = JParser.MAXIMUM_SUPPORTED_JAVA_VERSION.effectiveJavaVersionAsString(); String unitName = "C.java"; String source = "class C { }"; @@ -72,19 +79,19 @@ void test_first_index_of_tokens_in_eclipse_ast() { astParser.setUnitName(unitName); astParser.setSource(source.toCharArray()); CompilationUnit compilationUnit = (CompilationUnit) astParser.createAST(null); - TokenManager tokenManager = JDTParser.createTokenManager(version, unitName, source); + TokenManager tokenManager = JDTAstConverter.createTokenManager(version, unitName, source); - assertThat(JDTParser.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNameIdentifier, TerminalToken.TokenNameLBRACE)).isEqualTo(1); - assertThat(JDTParser.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNameLBRACE, TerminalToken.TokenNameIdentifier)).isEqualTo(1); - assertThat(JDTParser.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNameRBRACE, TerminalToken.TokenNameLBRACE)).isEqualTo(2); - assertThatThrownBy(() -> JDTParser.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNamebreak, TerminalToken.TokenNameconst)) + assertThat(JDTAstConverter.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNameIdentifier, TerminalToken.TokenNameLBRACE)).isEqualTo(1); + assertThat(JDTAstConverter.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNameLBRACE, TerminalToken.TokenNameIdentifier)).isEqualTo(1); + assertThat(JDTAstConverter.firstIndexIn(tokenManager, compilationUnit, TerminalToken.TokenNameRBRACE, TerminalToken.TokenNameLBRACE)).isEqualTo(2); + assertThatThrownBy(() -> JDTAstConverter.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"); } @Test void test_comment_tokens() { - String version = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION.effectiveJavaVersionAsString(); + String version = JParser.MAXIMUM_SUPPORTED_JAVA_VERSION.effectiveJavaVersionAsString(); String unitName = "C.java"; String source = """ class A { @@ -98,7 +105,7 @@ class A { void foo() {} } """; - TokenManager tokens = JDTParser.createTokenManager(version, unitName, source); + TokenManager tokens = JDTAstConverter.createTokenManager(version, unitName, source); assertThat(tokens.size()).isEqualTo(15); @@ -146,7 +153,7 @@ void failing_batch_mode_should_continue_file_by_file() { TestUtils.inputFile("src/test/files/metrics/Classes.java"), TestUtils.inputFile("src/test/files/metrics/Methods.java")); List trace = new ArrayList<>(); - BiConsumer action = (inputFile, result) -> { + BiConsumer action = (inputFile, result) -> { trace.addAll(logTester.logs()); logTester.clear(); try { @@ -174,12 +181,12 @@ void successful_batch_mode_with_missing_analyzed_files_should_continue_file_by_f List inputFiles = Arrays.asList( TestUtils.inputFile("src/test/files/metrics/Classes.java"), TestUtils.inputFile("src/test/files/metrics/Methods.java")); - BiConsumer doNothingAction = (inputFile, result) -> {}; - JDTParserConfig config = spy((JDTParserConfig) JParserConfig.Mode.BATCH + BiConsumer doNothingAction = (inputFile, result) -> {}; + JDTParser config = spy((JDTParser) JParser.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.jdtParser()).thenReturn(astParser); + doReturn(astParser).when(config).jdtAstParser(); config.parse(inputFiles, () -> false, new AnalysisProgress(inputFiles.size()), doNothingAction); @@ -196,7 +203,7 @@ void failing_batch_mode_should_stop_file_by_file_when_cancelled() { TestUtils.inputFile("src/test/files/metrics/Methods.java")); List trace = new ArrayList<>(); AtomicBoolean isCanceled = new AtomicBoolean(false); - BiConsumer action = (inputFile, result) -> { + BiConsumer action = (inputFile, result) -> { trace.addAll(logTester.logs()); logTester.clear(); try { @@ -209,7 +216,7 @@ void failing_batch_mode_should_stop_file_by_file_when_cancelled() { } }; - JParserConfig config = BATCH + JParser config = BATCH .create(MAXIMUM_SUPPORTED_JAVA_VERSION, List.of(), false); AnalysisProgress analysisProgress = new AnalysisProgress(inputFiles.size()); assertThatThrownBy(() -> config.parse(inputFiles, isCanceled::get, analysisProgress, action)) @@ -228,7 +235,7 @@ void failing_batch_mode_should_stop_file_by_file_when_cancelled() { void failing_batch_mode_with_empty_file_list_should_not_continue_file_by_file() { List inputFiles = List.of(); List trace = new ArrayList<>(); - BiConsumer action = (inputFile, result) -> trace.add("should not be called "); + BiConsumer action = (inputFile, result) -> trace.add("should not be called "); BatchWithException batchWithException = new BatchWithException(); // exception before the first file batchWithException.exceptions.push(new NullPointerException("Boom!")); @@ -239,7 +246,42 @@ void failing_batch_mode_with_empty_file_list_should_not_continue_file_by_file() "Unexpected NullPointerException: Boom!"); } - static class BatchWithException extends JDTParserConfig.Batch { + @ParameterizedTest + @EnumSource(JParser.Mode.class) + void should_preserve_configuration_between_parses(JParser.Mode mode, @TempDir Path directory) throws Exception { + JParser parser = mode.create(new JavaVersionImpl(17), List.of()); + for (String name : List.of("A", "B")) { + Path sourceFile = Files.writeString(directory.resolve(name + ".java"), "record " + name + "(String value) {}"); + InputFile inputFile = TestUtils.inputFile(sourceFile.toFile()); + List results = new ArrayList<>(); + parser.parse(List.of(inputFile), () -> false, new AnalysisProgress(1), (input, result) -> results.add(result)); + assertThat(results).hasSize(1); + var tree = results.getFirst().get(); + assertThat(tree.semanticProblems()).isEmpty(); + ClassTree recordTree = (ClassTree) tree.types().get(0); + assertThat(recordTree.recordComponents().get(0).symbol().type().is("java.lang.String")).isTrue(); + } + assertThat(logTester.logs(Level.WARN)).isEmpty(); + } + + @Test + void should_enable_preview() { + assertThat(shouldEnablePreviewFlag(new JavaVersionImpl())).isFalse(); + assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(8))).isFalse(); + assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(11))).isFalse(); + assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(16))).isFalse(); + assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(17))).isFalse(); + assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(18))).isFalse(); + assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(19))).isFalse(); + assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(20))).isFalse(); + assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(42))).isFalse(); + assertThat(shouldEnablePreviewFlag(new JavaVersionImpl(42, true))).isTrue(); + + assertThat(shouldEnablePreviewFlag(JavaVersionImpl.fromString("1.8"))).isFalse(); + assertThat(shouldEnablePreviewFlag(JavaVersionImpl.fromString("1.8", "True"))).isTrue(); + } + + static class BatchWithException extends JDTParser.Batch { Deque exceptions = new LinkedList<>(); @@ -248,11 +290,11 @@ public BatchWithException() { } @Override - public ASTParser jdtParser() { + public ASTParser jdtAstParser() { if (!exceptions.isEmpty()) { throw exceptions.pop(); } - return super.jdtParser(); + return super.jdtAstParser(); } } diff --git a/java-frontend/src/test/java/org/sonar/java/jdt/JDTSemaTest.java b/java-frontend/src/test/java/org/sonar/java/jdt/JDTSemaTest.java index 220798b7aa3..7aa4da3ac49 100644 --- a/java-frontend/src/test/java/org/sonar/java/jdt/JDTSemaTest.java +++ b/java-frontend/src/test/java/org/sonar/java/jdt/JDTSemaTest.java @@ -23,7 +23,7 @@ import org.eclipse.jdt.core.dom.ITypeBinding; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import org.sonar.java.model.JParserConfig; +import org.sonar.java.model.JParser; import static org.assertj.core.api.Assertions.assertThat; @@ -42,7 +42,7 @@ void type() { @BeforeEach void setup() { ASTParser astParser = ASTParser.newParser(AST.getJLSLatest()); - String version = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION.effectiveJavaVersionAsString(); + String version = JParser.MAXIMUM_SUPPORTED_JAVA_VERSION.effectiveJavaVersionAsString(); JavaCore.setComplianceOptions(version, JavaCore.getOptions()); astParser.setEnvironment( new String[]{"target/test-classes"}, diff --git a/java-frontend/src/test/java/org/sonar/java/model/DefaultModuleScannerContextTest.java b/java-frontend/src/test/java/org/sonar/java/model/DefaultModuleScannerContextTest.java index 3a1ab93bd38..dbc0d8fc961 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/DefaultModuleScannerContextTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/DefaultModuleScannerContextTest.java @@ -52,7 +52,7 @@ void test_addIssueOnProject_delegates_to_SonarComponents() { doNothing().when(sonarComponents).addIssue(any(InputComponent.class), any(JavaCheck.class), any(int.class), any(String.class), any(int.class)); var context = new DefaultModuleScannerContext( sonarComponents, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, false, null ); @@ -67,7 +67,7 @@ void test_addIssueOnProject_delegates_to_SonarComponents() { void test_getJavaVersion_returns_expected_version() { var context = new DefaultModuleScannerContext( null, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, true, null ); @@ -85,14 +85,14 @@ void test_getJavaVersion_returns_expected_version() { void test_inAndroidContext_returns_expected_version() { var context = new DefaultModuleScannerContext( null, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, true, null ); assertThat(context.inAndroidContext()).isTrue(); context = new DefaultModuleScannerContext( null, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, false, null ); @@ -108,7 +108,7 @@ void test_getProject_delegates_to_SonarComponents() { doReturn(inputComponent).when(sonarComponents).project(); var context = new DefaultModuleScannerContext( sonarComponents, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, true, null ); @@ -127,7 +127,7 @@ void test_getWorkingDirectory_delegates_to_SonarComponents() { doReturn(expectedWorkDir).when(sonarComponents).projectLevelWorkDir(); var context = new DefaultModuleScannerContext( sonarComponents, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, true, null ); @@ -143,7 +143,7 @@ void test_getCacheContext_returns_a_disabled_cache_when_no_sensor_context() { doReturn(null).when(sonarComponents).context(); var context = new DefaultModuleScannerContext( sonarComponents, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, true, null ); @@ -162,7 +162,7 @@ void test_getCacheContext_returns_a_disabled_cache_when_caching_is_server_disabl var context = new DefaultModuleScannerContext( sonarComponents, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, true, null ); @@ -177,7 +177,7 @@ void test_getCacheContext_returns_the_CacheContext_passed_at_construction() { var cacheContext = mock(CacheContext.class); var context = new DefaultModuleScannerContext( null, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, true, cacheContext ); @@ -192,7 +192,7 @@ void getRootProjectWorkingDirectory_returns_the_working_dir_from_sonarComponents var context = new DefaultModuleScannerContext( sonarComponents, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, false, null ); @@ -213,7 +213,7 @@ void should_properly_report_sonar_product(SonarProduct product) { var context = new DefaultModuleScannerContext( sonarComponents, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, false, null ); @@ -226,7 +226,7 @@ void should_properly_report_sonar_product(SonarProduct product) { void should_not_report_product_if_sonarcomponents_is_not_available() { var context = new DefaultModuleScannerContext( null, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, false, null ); @@ -242,7 +242,7 @@ void should_not_report_product_if_no_sensor_context_is_available() { var context = new DefaultModuleScannerContext( sonarComponents, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, false, null ); @@ -259,7 +259,7 @@ void test_getConfiguration() { var context = new DefaultModuleScannerContext( sonarComponents, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, false, null ); diff --git a/java-frontend/src/test/java/org/sonar/java/model/JParserConfigTest.java b/java-frontend/src/test/java/org/sonar/java/model/JParserModeTest.java similarity index 82% rename from java-frontend/src/test/java/org/sonar/java/model/JParserConfigTest.java rename to java-frontend/src/test/java/org/sonar/java/model/JParserModeTest.java index a03ca80e012..c592ae4f5d5 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JParserConfigTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JParserModeTest.java @@ -24,17 +24,17 @@ import static org.assertj.core.api.Assertions.assertThat; -class JParserConfigTest { +class JParserModeTest { @RegisterExtension public ThreadLocalLogTester logTester = new ThreadLocalLogTester().setLevel(Level.INFO); @Test void a_debug_message_is_logged_when_shouldIgnoreUnnamedModuleForSplitPackage_is_set() { - JParserConfig.Mode.BATCH.create(new JavaVersionImpl(17), Collections.emptyList()); + JParser.Mode.BATCH.create(new JavaVersionImpl(17), Collections.emptyList()); assertThat(logTester.logs()).isEmpty(); - JParserConfig.Mode.BATCH.create(new JavaVersionImpl(17), Collections.emptyList(), false); + JParser.Mode.BATCH.create(new JavaVersionImpl(17), Collections.emptyList(), false); assertThat(logTester.logs()).isEmpty(); - JParserConfig.Mode.BATCH.create(new JavaVersionImpl(17), Collections.emptyList(), true); + JParser.Mode.BATCH.create(new JavaVersionImpl(17), Collections.emptyList(), true); assertThat(logTester.logs()).containsExactly("The Java analyzer will ignore the unnamed module for split packages."); } } 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 239186e7882..e6363afff83 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 @@ -17,6 +17,7 @@ package org.sonar.java.model; import com.sonar.sslr.api.RecognitionException; +import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder; import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; @@ -46,7 +47,6 @@ import org.sonar.api.batch.fs.InputFile; import org.sonar.java.AnalysisProgress; import org.sonar.java.TestUtils; -import org.sonar.java.model.JParserConfig.Result; import org.sonar.java.model.declaration.ClassTreeImpl; import org.sonar.java.testing.ThreadLocalLogTester; import org.sonar.plugins.java.api.JavaVersion; @@ -86,9 +86,9 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; -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; +import static org.sonar.java.model.JParser.MAXIMUM_SUPPORTED_JAVA_VERSION; +import static org.sonar.java.model.JParser.Mode.BATCH; +import static org.sonar.java.model.JParser.Mode.FILE_BY_FILE; import static org.sonar.java.model.JParserTestUtils.DEFAULT_CLASSPATH; import static org.sonar.java.model.JParserTestUtils.parse; @@ -116,8 +116,12 @@ 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")); - JParserConfig config = FILE_BY_FILE.create(JavaVersionImpl.fromString(version), classpath); - assertThrows(RecognitionException.class, () -> config.parse("A", "class A { }")); + JParser config = FILE_BY_FILE.create(JavaVersionImpl.fromString(version), classpath); + InputFile inputFile = new TestInputFileBuilder("", "A.java").setContents("class A { }").build(); + List results = new ArrayList<>(); + config.parse(List.of(inputFile), () -> false, new AnalysisProgress(1), (input, result) -> results.add(result)); + assertThat(results).hasSize(1); + assertThrows(RecognitionException.class, results.getFirst()::get); } @Test @@ -151,7 +155,7 @@ void warnings_are_collected() { @Test void should_rethrow_when_consumer_throws() { RuntimeException expected = new RuntimeException(); - BiConsumer consumer = (inputFile, result) -> { + BiConsumer consumer = (inputFile, result) -> { throw expected; }; InputFile inputFile = mock(InputFile.class); @@ -159,7 +163,7 @@ void should_rethrow_when_consumer_throws() { .when(inputFile).absolutePath(); Set inputFiles = Collections.singleton(inputFile); - JParserConfig config = JParserConfig.Mode.FILE_BY_FILE.create(MAXIMUM_SUPPORTED_JAVA_VERSION, Collections.emptyList()); + JParser config = JParser.Mode.FILE_BY_FILE.create(MAXIMUM_SUPPORTED_JAVA_VERSION, Collections.emptyList()); AnalysisProgress analysisProgress = new AnalysisProgress(inputFiles.size()); RuntimeException actual = assertThrows(RuntimeException.class, () -> config.parse(inputFiles, () -> false, @@ -169,8 +173,8 @@ void should_rethrow_when_consumer_throws() { @Test void consumer_should_receive_exceptions_thrown_during_parsing() throws Exception { - List results = new ArrayList<>(); - BiConsumer consumer = (inputFile, result) -> results.add(result); + List results = new ArrayList<>(); + BiConsumer consumer = (inputFile, result) -> results.add(result); InputFile inputFile = mock(InputFile.class); doReturn("/tmp/Example.java") @@ -182,14 +186,14 @@ void consumer_should_receive_exceptions_thrown_during_parsing() throws Exception .create(MAXIMUM_SUPPORTED_JAVA_VERSION, Collections.emptyList()) .parse(Collections.singleton(inputFile), () -> false, new AnalysisProgress(1), consumer); - Result result = results.get(0); + JParseResult result = results.get(0); assertThrows(IOException.class, result::get); } @Test void consumer_should_receive_exceptions_thrown_during_parsing_as_batch() throws Exception { - List results = new ArrayList<>(); - BiConsumer consumer = (inputFile, result) -> results.add(result); + List results = new ArrayList<>(); + BiConsumer consumer = (inputFile, result) -> results.add(result); InputFile inputFile = spy(TestUtils.inputFile("src/test/files/metrics/Classes.java")); when(inputFile.contents()).thenThrow(IOException.class); @@ -197,18 +201,18 @@ void consumer_should_receive_exceptions_thrown_during_parsing_as_batch() throws .create(MAXIMUM_SUPPORTED_JAVA_VERSION, Collections.emptyList()) .parse(Collections.singleton(inputFile), () -> false, new AnalysisProgress(1), consumer); - Result result = results.get(0); + JParseResult result = results.get(0); assertThrows(IOException.class, result::get); } @Test void should_propagate_exception_raised_by_batch_parsing() { NullPointerException expected = new NullPointerException(""); - BiConsumer consumerThrowing = (inputFile, result) -> { + BiConsumer consumerThrowing = (inputFile, result) -> { throw expected; }; List inputFiles = Collections.singletonList(TestUtils.inputFile("src/test/files/metrics/Classes.java")); - JParserConfig config = BATCH.create(MAXIMUM_SUPPORTED_JAVA_VERSION, DEFAULT_CLASSPATH); + JParser config = BATCH.create(MAXIMUM_SUPPORTED_JAVA_VERSION, DEFAULT_CLASSPATH); AnalysisProgress analysisProgress = new AnalysisProgress(inputFiles.size()); NullPointerException actual = assertThrows(NullPointerException.class, () -> config.parse(inputFiles, () -> false, analysisProgress, consumerThrowing)); @@ -542,7 +546,7 @@ void dont_include_running_VM_Bootclasspath_if_jvm_jrt_fs_jar_already_provided_in void test_parse_file_by_file() throws Exception { List inputFiles = Arrays.asList(TestUtils.inputFile("src/test/files/metrics/Classes.java"), TestUtils.inputFile("src/test/files/metrics/Methods.java")); - List results = new ArrayList<>(); + List results = new ArrayList<>(); List inputFilesProcessed = new ArrayList<>(); FILE_BY_FILE .create(MAXIMUM_SUPPORTED_JAVA_VERSION, DEFAULT_CLASSPATH) @@ -558,7 +562,7 @@ void test_parse_file_by_file() throws Exception { void test_parse_as_batch() throws Exception { List inputFiles = Arrays.asList(TestUtils.inputFile("src/test/files/metrics/Classes.java"), TestUtils.inputFile("src/test/files/metrics/Methods.java")); - List results = new ArrayList<>(); + List results = new ArrayList<>(); List inputFilesProcessed = new ArrayList<>(); BATCH .create(MAXIMUM_SUPPORTED_JAVA_VERSION, DEFAULT_CLASSPATH) @@ -625,7 +629,7 @@ public static List tokens(JavaTree tree) { return tokens; } - private void assertResultsOfParsing(List results, List inputFilesProcessed) throws Exception { + private void assertResultsOfParsing(List results, List inputFilesProcessed) throws Exception { assertThat(inputFilesProcessed).hasSize(2); assertThat(inputFilesProcessed.get(0).filename()).isEqualTo("Classes.java"); assertThat(inputFilesProcessed.get(1).filename()).isEqualTo("Methods.java"); @@ -644,7 +648,7 @@ private void assertResultsOfParsing(List results, List inputF void test_is_canceled_is_called_before_each_action_file_by_file() { List inputFiles = Arrays.asList(TestUtils.inputFile("src/test/files/metrics/Classes.java"), TestUtils.inputFile("src/test/files/metrics/Methods.java")); - BiConsumer action = mock(BiConsumer.class); + BiConsumer action = mock(BiConsumer.class); BooleanSupplier isCanceled = mock(BooleanSupplier.class); FILE_BY_FILE @@ -662,7 +666,7 @@ void test_is_canceled_is_called_before_each_action_file_by_file() { void test_is_canceled_is_called_file_by_file() { List inputFiles = Arrays.asList(TestUtils.inputFile("src/test/files/metrics/Classes.java"), TestUtils.inputFile("src/test/files/metrics/Methods.java")); - List results = new ArrayList<>(); + List results = new ArrayList<>(); FILE_BY_FILE .create(MAXIMUM_SUPPORTED_JAVA_VERSION, DEFAULT_CLASSPATH) .parse(inputFiles, () -> true, new AnalysisProgress(inputFiles.size()), (inputFile, result) -> results.add(result)); @@ -774,7 +778,7 @@ private static void add(File source, File baseDir, JarOutputStream target) { } private VariableTree parseAndGetVariable(String code, File... classpath) { - return parseAndGetVariable(code, JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, classpath); + return parseAndGetVariable(code, JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, classpath); } private VariableTree parseAndGetVariable(String code, JavaVersion javaVersion, File... classpath) { diff --git a/java-frontend/src/test/java/org/sonar/java/model/JParserTestUtils.java b/java-frontend/src/test/java/org/sonar/java/model/JParserTestUtils.java index 98ba3fa0512..d80e7603da1 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/JParserTestUtils.java +++ b/java-frontend/src/test/java/org/sonar/java/model/JParserTestUtils.java @@ -17,6 +17,7 @@ package org.sonar.java.model; import com.google.common.io.Files; +import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder; import java.io.File; import java.io.IOException; import java.nio.charset.StandardCharsets; @@ -26,6 +27,7 @@ import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; +import org.sonar.java.AnalysisProgress; import org.sonar.java.test.classpath.TestClasspathUtils; import org.sonar.plugins.java.api.JavaVersion; import org.sonar.plugins.java.api.semantic.Sema; @@ -115,11 +117,24 @@ public static CompilationUnitTree parse(String source, JavaVersion version) { } public static CompilationUnitTree parse(String unitName, String source, List classpath) { - return parse(unitName, source, classpath, JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION); + return parse(unitName, source, classpath, JParser.MAXIMUM_SUPPORTED_JAVA_VERSION); } public static CompilationUnitTree parse(String unitName, String source, List classpath, JavaVersion version) { - return JParserConfig.Mode.FILE_BY_FILE.create(version, classpath).parse(unitName, source); + var inputFile = new TestInputFileBuilder("", unitName) + .setContents(source) + .setCharset(StandardCharsets.UTF_8) + .build(); + List results = new ArrayList<>(); + JParser.Mode.FILE_BY_FILE.create(version, classpath) + .parse(List.of(inputFile), () -> false, new AnalysisProgress(1), (input, result) -> results.add(result)); + try { + return results.getFirst().get(); + } catch (RuntimeException e) { + throw e; + } catch (Exception e) { + throw new IllegalStateException("Unable to parse source", e); + } } public static List checksTestClassPath() throws IOException { diff --git a/java-frontend/src/test/java/org/sonar/java/model/MethodSymbolTest.java b/java-frontend/src/test/java/org/sonar/java/model/MethodSymbolTest.java index 4144502c806..c40dfaee409 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/MethodSymbolTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/MethodSymbolTest.java @@ -184,8 +184,8 @@ void test_forward_declaration_in_the_same_batch() { TestUtils.inputFile("src/test/files/semantic/GenericDependency.java"), TestUtils.inputFile("src/test/files/semantic/Nullable.java")); List processed = new ArrayList<>(); - JParserConfig.Mode.BATCH - .create(JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION, JParserTestUtils.DEFAULT_CLASSPATH) + JParser.Mode.BATCH + .create(JParser.MAXIMUM_SUPPORTED_JAVA_VERSION, JParserTestUtils.DEFAULT_CLASSPATH) .parse(inputFiles, () -> false, new AnalysisProgress(inputFiles.size()), (inputFile, result) -> { processed.add(inputFile.filename()); if (inputFile.filename().equals("Main.java")) { diff --git a/java-frontend/src/test/java/org/sonar/java/model/VisitorsBridgeTest.java b/java-frontend/src/test/java/org/sonar/java/model/VisitorsBridgeTest.java index 76df3e194d3..48000d77488 100644 --- a/java-frontend/src/test/java/org/sonar/java/model/VisitorsBridgeTest.java +++ b/java-frontend/src/test/java/org/sonar/java/model/VisitorsBridgeTest.java @@ -438,7 +438,7 @@ void visitorsBridge_uses_appropriate_scanners() throws ApiMismatchException { List.of(skippableVisitor, endOfAnalysisVisitor, unskippableVisitor, incompatibleVisitor), Collections.emptyList(), specificSonarComponents, - JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION + JParser.MAXIMUM_SUPPORTED_JAVA_VERSION ); verify(skippableVisitor, times(1)).nodesToVisit(); diff --git a/sonar-java-plugin/src/main/resources/static/documentation.md b/sonar-java-plugin/src/main/resources/static/documentation.md index 6a9ac63b75c..8b7a205a56d 100644 --- a/sonar-java-plugin/src/main/resources/static/documentation.md +++ b/sonar-java-plugin/src/main/resources/static/documentation.md @@ -155,13 +155,17 @@ The tutorial [Writing Custom Java Rules 101](https://redirect.sonarsource.com/do **Breaking** -* `org.sonar.java.model.JParser` is now an interface. Its instance method `parse(String version, String unitName, String source)` returns a `JavaTree.CompilationUnitTreeImpl`. - The static helper `JParser.parse(...)` now takes a `JParser` as its first argument instead of an ECJ `ASTParser`. -* `org.sonar.java.model.JParserConfig` is now an interface. `astParser()` returns a `JParser` instead of an ECJ `ASTParser`. - Use the new `parse(String unitName, String source)` method to parse source with the configured Java version, or call `astParser().parse(version, unitName, source)` to supply the version explicitly. - The `Mode.BATCH.create(...)` and `Mode.FILE_BY_FILE.create(...)` factories and the multi-file `parse(...)` method remain available. - The multi-file `parse(...)` method now takes `Iterable` instead of `Iterable`; callers must supply an `Iterable`, and implementations must update their override signatures. This change preserves binary compatibility because type erasure is unchanged. - `JParserConfig.Result` is now final and provides `success(tree)` and `failure(exception)` factories; `get()` returns the tree or rethrows the parsing exception. +* `org.sonar.java.model.JParser` is now an interface, independent of the underlying parser implementation, and replaces `JParserConfig`. + Create parsers with `JParser.Mode.BATCH.create(JavaVersion, List)` or `JParser.Mode.FILE_BY_FILE.create(JavaVersion, List)`. Both factories also accept an optional third `boolean` argument to ignore the unnamed module for split packages. + The string-based `parse(String version, String unitName, String source)` overload has been removed. Use `JParser#parse(Iterable, BooleanSupplier, AnalysisProgress, BiConsumer)` for all parsing, including a single file supplied as `List.of(inputFile)`. + The Java version and classpath are set when creating the parser; source contents, filename, and charset come from each `InputFile`. + The input parameter now takes `Iterable` instead of `Iterable`; callers must supply an `Iterable`, and implementations must update their override signatures. Code compiled against `JParserConfig` must be recompiled. + Parsing callbacks now receive `org.sonar.java.model.JParseResult` instead of `JParserConfig.Result`. `JParseResult` is final and provides `success(tree)` and `failure(exception)` factories; `get()` returns the tree or rethrows the parsing exception. +* ECJ-specific implementation classes have moved from `org.sonar.java.model` to `org.sonar.java.jdt` and use the `JDT` prefix, including `JSema`, `JType`, `JSymbol`, `JMethodSymbol`, `JTypeSymbol`, `JVariableSymbol`, `JInitializerBlockSymbol`, `JSymbolMetadata`, `JProblem`, and `JWarning`. + Custom rules should use the semantic and diagnostics interfaces in `org.sonar.plugins.java.api` instead of depending on these implementations. +* `JSymbolMetadata.JNullabilityData` is now the top-level class `org.sonar.java.model.JNullabilityData`. The `noNullabilityAnnotationAt(...)` and `unknownNullabilityAt(...)` factories have also moved from `JSymbolMetadata` to `JNullabilityData`. +* `JUtils#collectSuperTypes(Set, JSema, ITypeBinding)` has been removed. Use `TypeSymbol#superTypes()` to retrieve the transitive supertypes through the semantic API. + `JUtils#defaultValue(MethodSymbol)` now returns values in the same representation as `SymbolMetadata.AnnotationValue#value()`, rather than ECJ bindings. Callers handling class, enum, or annotation defaults must use the semantic API types. * AST node implementations no longer expose ECJ-specific bindings such as `IBinding`, `ITypeBinding`, `IMethodBinding`, and `IVariableBinding`. Nodes store `org.sonar.plugins.java.api.semantic.Type` and `Symbol` values, including `Symbol.TypeSymbol` and `Symbol.MethodSymbol`, directly. Custom rules accessing implementation fields such as `binding` or `typeBinding` must use the tree API's `symbol()`, `methodSymbol()`, and `symbolType()` accessors instead. diff --git a/sonar-java-plugin/src/test/java/org/sonar/plugins/java/SanityTest.java b/sonar-java-plugin/src/test/java/org/sonar/plugins/java/SanityTest.java index d622549b27e..736c0bb8b2b 100644 --- a/sonar-java-plugin/src/test/java/org/sonar/plugins/java/SanityTest.java +++ b/sonar-java-plugin/src/test/java/org/sonar/plugins/java/SanityTest.java @@ -49,7 +49,7 @@ import org.sonar.java.SonarComponents; import org.sonar.java.ast.JavaAstScanner; import org.sonar.java.checks.verifier.FilesUtils; -import org.sonar.java.model.JParserConfig; +import org.sonar.java.model.JParser; import org.sonar.java.telemetry.NoOpTelemetry; import org.sonar.java.telemetry.TelemetryKey; import org.sonar.java.testing.VisitorsBridgeForTests; @@ -232,7 +232,7 @@ private static boolean isNotParsingErrorFile(String filename) { private static List scanFiles(File moduleBaseDir, List inputFiles, List checks, List classpath) { SonarComponents sonarComponents = sonarComponents(moduleBaseDir, inputFiles); JavaAstScanner scanner = new JavaAstScanner(sonarComponents, new NoOpTelemetry(), TelemetryKey.JAVA_ANALYSIS_MAIN); - JavaVersion javaVersion = JParserConfig.MAXIMUM_SUPPORTED_JAVA_VERSION; + JavaVersion javaVersion = JParser.MAXIMUM_SUPPORTED_JAVA_VERSION; scanner.setVisitorBridge(new VisitorsBridgeForTests.Builder(checks) .enableSemanticWithProjectClasspath(classpath) .withSonarComponents(sonarComponents) @@ -240,7 +240,7 @@ private static List scanFiles(File moduleBaseDir, List exceptions = new ArrayList<>(); AnalysisProgress analysisProgress = new AnalysisProgress(inputFiles.size()); - JParserConfig.Mode.BATCH + JParser.Mode.BATCH .create(javaVersion, classpath, true) .parse(inputFiles, () -> false, analysisProgress, (input, result) -> { try {