Replace shared-tree compiler bindings with lazy semantic values

Author: aurelien-coet-sonarsource

java-checks/src/test/java/org/sonar/java/checks/DeadStoreCheckTest.java

@@ -19,6 +19,7 @@
 import org.junit.jupiter.api.Test;
 import org.sonar.java.checks.verifier.CheckVerifier;
 import org.sonar.java.checks.verifier.TestUtils;
+import org.sonar.java.model.SemanticValues;
 import org.sonar.java.model.declaration.VariableTreeImpl;
 import org.sonar.plugins.java.api.tree.BaseTreeVisitor;
 import org.sonar.plugins.java.api.tree.VariableTree;
@@ -64,7 +65,7 @@ private static class EraseSymbols extends BaseTreeVisitor {
     @Override
     public void visitVariable(VariableTree tree) {
       if (tree instanceof VariableTreeImpl varImpl) {
-        varImpl.variableBinding = null;
+        varImpl.variableSymbol = SemanticValues.UNKNOWN_SYMBOL;
       }
       super.visitVariable(tree);
     }

java-frontend/src/main/java/org/sonar/java/ast/JavaAstScanner.java

@@ -166,7 +166,7 @@ public void simpleScan(InputFile inputFile, JParserConfig.Result result, Consume
       modifyCompilationUnit.accept(ast);
       visitor.visitFile(ast, sonarComponents != null && sonarComponents.fileCanBeSkipped(inputFile));
       String path = inputFile.toString();
-      Set<JProblem> undefinedTypes = ast.sema.undefinedTypes();
+      Set<JProblem> undefinedTypes = ast.undefinedTypes();
       collectUndefinedTypes(path, undefinedTypes);
       cleanUp.accept(ast);
       telemetryAnalysisKeys = javaAnalysisKeys.success();

java-frontend/src/main/java/org/sonar/java/model/AbstractTypedTree.java

@@ -16,23 +16,18 @@
  */
 package org.sonar.java.model;
 
-import org.eclipse.jdt.core.dom.ITypeBinding;
+import java.util.function.Supplier;
 import org.sonar.plugins.java.api.semantic.Type;
 
-import javax.annotation.Nullable;
-
 /**
  * This class is intended for internal use during semantic analysis and should not be used in checks.
  */
 public abstract class AbstractTypedTree extends JavaTree {
 
-  @Nullable
-  public ITypeBinding typeBinding;
+  public Supplier<Type> type = SemanticValues.UNKNOWN_TYPE;
 
   public Type symbolType() {
-    return typeBinding != null
-      ? root.sema.type(typeBinding)
-      : Type.UNKNOWN;
+    return type.get();
   }
 
 }

java-frontend/src/main/java/org/sonar/java/model/EcjSemanticAttachment.java

@@ -0,0 +1,48 @@
+/*
+ * SonarQube Java
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.java.model;
+
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import javax.annotation.Nullable;
+import org.eclipse.jdt.core.dom.IBinding;
+
+final class EcjSemanticAttachment<B extends IBinding, T> implements Supplier<T> {
+
+  final B binding;
+  private final Function<B, T> factory;
+  private T value;
+
+  EcjSemanticAttachment(B binding, Function<B, T> factory) {
+    this.binding = binding;
+    this.factory = factory;
+  }
+
+  @Override
+  public T get() {
+    if (value == null) {
+      value = Objects.requireNonNull(factory.apply(binding));
+    }
+    return value;
+  }
+
+  @Nullable
+  static IBinding getBinding(Supplier<?> attachment) {
+    return attachment instanceof EcjSemanticAttachment<?, ?> ecj ? ecj.binding : null;
+  }
+}

java-frontend/src/main/java/org/sonar/java/model/EcjTreeBindings.java

@@ -0,0 +1,103 @@
+/*
+ * SonarQube Java
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.java.model;
+
+import java.util.function.Supplier;
+import javax.annotation.Nullable;
+import org.eclipse.jdt.core.dom.IBinding;
+import org.eclipse.jdt.core.dom.IMethodBinding;
+import org.eclipse.jdt.core.dom.ITypeBinding;
+import org.eclipse.jdt.core.dom.IVariableBinding;
+import org.sonar.java.model.declaration.ClassTreeImpl;
+import org.sonar.java.model.declaration.MethodTreeImpl;
+import org.sonar.java.model.declaration.VariableTreeImpl;
+import org.sonar.java.model.expression.IdentifierTreeImpl;
+import org.sonar.java.model.expression.LambdaExpressionTreeImpl;
+import org.sonar.java.model.expression.MethodInvocationTreeImpl;
+import org.sonar.java.model.pattern.AbstractPatternTree;
+
+final class EcjTreeBindings {
+
+  private EcjTreeBindings() {
+  }
+
+  @Nullable
+  static ITypeBinding typeBinding(Object tree) {
+    return switch (tree) {
+      case AbstractTypedTree t -> (ITypeBinding) EcjSemanticAttachment.getBinding(t.type);
+      case ClassTreeImpl t -> (ITypeBinding) EcjSemanticAttachment.getBinding(t.typeSymbol);
+      case TypeParameterTreeImpl t -> (ITypeBinding) EcjSemanticAttachment.getBinding(t.typeSymbol);
+      case AbstractPatternTree t -> (ITypeBinding) EcjSemanticAttachment.getBinding(t.type);
+      default -> throw new IllegalArgumentException("No ECJ type attachment: " + tree.getClass());
+    };
+  }
+
+  @Nullable
+  static IMethodBinding methodBinding(Object tree) {
+    Supplier<?> attachment = switch (tree) {
+      case MethodTreeImpl t -> t.methodSymbol;
+      case MethodInvocationTreeImpl t -> t.methodSymbolSupplier;
+      case LambdaExpressionTreeImpl t -> t.methodSymbol;
+      default -> throw new IllegalArgumentException("No ECJ method attachment: " + tree.getClass());
+    };
+    return (IMethodBinding) EcjSemanticAttachment.getBinding(attachment);
+  }
+
+  @Nullable
+  static IVariableBinding variableBinding(VariableTreeImpl tree) {
+    return (IVariableBinding) EcjSemanticAttachment.getBinding(tree.variableSymbol);
+  }
+
+  @Nullable
+  static IBinding binding(Object tree) {
+    return switch (tree) {
+      case IdentifierTreeImpl t -> EcjSemanticAttachment.getBinding(t.symbolSupplier);
+      case JavaTree.ImportTreeImpl t -> EcjSemanticAttachment.getBinding(t.symbolSupplier);
+      default -> throw new IllegalArgumentException("No ECJ symbol attachment: " + tree.getClass());
+    };
+  }
+
+  static void setType(JSema sema, JavaTree tree, @Nullable ITypeBinding binding) {
+    switch (tree) {
+      case AbstractTypedTree t -> t.type = sema.typeSupplier(binding);
+      case ClassTreeImpl t -> t.typeSymbol = binding == null ? SemanticValues.UNKNOWN_TYPE_SYMBOL
+        : new EcjSemanticAttachment<>(binding, sema::typeSymbol);
+      case TypeParameterTreeImpl t -> t.typeSymbol = sema.symbolSupplier(binding);
+      default -> throw new IllegalArgumentException("No type attachment: " + tree.getClass());
+    }
+    if (tree instanceof KeywordThis t) {
+      t.symbolSupplier = binding == null ? SemanticValues.UNKNOWN_SYMBOL
+        : new EcjSemanticAttachment<>(binding, b -> sema.typeSymbol(b).thisSymbol);
+    } else if (tree instanceof KeywordSuper t) {
+      t.symbolSupplier = binding == null ? SemanticValues.UNKNOWN_SYMBOL
+        : new EcjSemanticAttachment<>(binding, b -> sema.typeSymbol(b).superSymbol);
+    }
+  }
+
+  static void setSymbol(JSema sema, JavaTree tree, @Nullable IBinding binding) {
+    switch (tree) {
+      case MethodTreeImpl t -> t.methodSymbol = sema.methodSupplier((IMethodBinding) binding);
+      case MethodInvocationTreeImpl t -> t.methodSymbolSupplier = sema.methodSupplier((IMethodBinding) binding);
+      case LambdaExpressionTreeImpl t -> t.methodSymbol = sema.methodSupplier((IMethodBinding) binding);
+      case VariableTreeImpl t -> t.variableSymbol = sema.symbolSupplier(binding);
+      case IdentifierTreeImpl t -> t.symbolSupplier = sema.symbolSupplier(binding);
+      case JavaTree.ImportTreeImpl t -> t.symbolSupplier = binding == null || binding.getKind() == IBinding.PACKAGE
+        || binding.getKind() == IBinding.MODULE ? () -> null : sema.symbolSupplier(binding);
+      default -> throw new IllegalArgumentException("No symbol attachment: " + tree.getClass());
+    }
+  }
+}