SONARPY-1807 SymbolTableBuilderV2 cleanup

Author: maksim-grebeniuk-sonarsource

python-frontend/src/main/java/org/sonar/python/semantic/v2/ReadUsagesVisitor.java

@@ -0,0 +1,148 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * 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 GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.semantic.v2;
+
+import java.util.Map;
+import org.sonar.plugins.python.api.tree.ClassDef;
+import org.sonar.plugins.python.api.tree.ComprehensionExpression;
+import org.sonar.plugins.python.api.tree.ComprehensionFor;
+import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.plugins.python.api.tree.FunctionDef;
+import org.sonar.plugins.python.api.tree.LambdaExpression;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.Parameter;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.tree.TypeAnnotation;
+import org.sonar.python.tree.DictCompExpressionImpl;
+
+/**
+ * Read (i.e. non-binding) usages have to be visited in a second phase.
+ * They can't be visited in the same phase as write (i.e. binding) usages,
+ * since a read usage may appear in the syntax tree "before" it's declared (written).
+ */
+public class ReadUsagesVisitor extends ScopeVisitor {
+  public ReadUsagesVisitor(Map<Tree, ScopeV2> scopesByRootTree) {
+    super(scopesByRootTree);
+  }
+
+  @Override
+  public void visitFileInput(FileInput tree) {
+    enterScope(tree);
+    super.visitFileInput(tree);
+  }
+
+  @Override
+  public void visitFunctionDef(FunctionDef pyFunctionDefTree) {
+    scan(pyFunctionDefTree.decorators());
+    enterScope(pyFunctionDefTree);
+    scan(pyFunctionDefTree.name());
+    scan(pyFunctionDefTree.typeParams());
+    scan(pyFunctionDefTree.parameters());
+    scan(pyFunctionDefTree.returnTypeAnnotation());
+    scan(pyFunctionDefTree.body());
+    leaveScope();
+  }
+
+  @Override
+  public void visitParameter(Parameter parameter) {
+    // parameter default value should not be in the function scope.
+    Tree currentScopeTree = leaveScope();
+    scan(parameter.defaultValue());
+    enterScope(currentScopeTree);
+    scan(parameter.name());
+    scan(parameter.typeAnnotation());
+  }
+
+  @Override
+  public void visitLambda(LambdaExpression pyLambdaExpressionTree) {
+    enterScope(pyLambdaExpressionTree);
+    super.visitLambda(pyLambdaExpressionTree);
+    leaveScope();
+  }
+
+  @Override
+  public void visitPyListOrSetCompExpression(ComprehensionExpression tree) {
+    enterScope(tree);
+    scan(tree.resultExpression());
+    ComprehensionFor comprehensionFor = tree.comprehensionFor();
+    scan(comprehensionFor.loopExpression());
+    leaveScope();
+    scan(comprehensionFor.iterable());
+    enterScope(tree);
+    scan(comprehensionFor.nestedClause());
+    leaveScope();
+  }
+
+  @Override
+  public void visitDictCompExpression(DictCompExpressionImpl tree) {
+    enterScope(tree);
+    scan(tree.keyExpression());
+    scan(tree.valueExpression());
+    ComprehensionFor comprehensionFor = tree.comprehensionFor();
+    scan(comprehensionFor.loopExpression());
+    leaveScope();
+    scan(comprehensionFor.iterable());
+    enterScope(tree);
+    scan(comprehensionFor.nestedClause());
+    leaveScope();
+  }
+
+  @Override
+  public void visitTypeAnnotation(TypeAnnotation tree) {
+    if (tree.is(Tree.Kind.PARAMETER_TYPE_ANNOTATION) || tree.is(Tree.Kind.RETURN_TYPE_ANNOTATION)) {
+      // The scope of the type annotations on a function declaration should be the scope enclosing the function, and not the scope of
+      // the function body itself. Note that this code assumes that we already entered the function body scope by visiting the type
+      // annotations, so there should always be a scope to pop out and return to here.
+      Tree currentScopeTree = leaveScope();
+      super.visitTypeAnnotation(tree);
+      enterScope(currentScopeTree);
+      super.visitTypeAnnotation(tree);
+    } else {
+      super.visitTypeAnnotation(tree);
+    }
+  }
+
+  @Override
+  public void visitClassDef(ClassDef classDef) {
+    scan(classDef.args());
+    scan(classDef.decorators());
+    enterScope(classDef);
+    scan(classDef.name());
+    scan(classDef.body());
+    leaveScope();
+  }
+
+  @Override
+  public void visitName(Name name) {
+    if (!name.isVariable()) {
+      return;
+    }
+    addSymbolUsage(name);
+    super.visitName(name);
+  }
+
+  private void addSymbolUsage(Name name) {
+    var scope = currentScope();
+    var symbol = scope.resolve(name.name());
+    if (symbol != null && symbol.usages().stream().noneMatch(usage -> usage.tree().equals(name))) {
+      symbol.addUsage(name, UsageV2.Kind.OTHER);
+    }
+  }
+}

python-frontend/src/main/java/org/sonar/python/semantic/v2/ScopeV2.java

@@ -34,13 +34,11 @@
 public class ScopeV2 {
   private final ScopeV2 parent;
   private final Tree rootTree;
-
   private final List<ScopeV2> childrenScopes;
-
-  final Map<String, SymbolV2> symbolsByName = new HashMap<>();
+  private final Map<String, SymbolV2> symbolsByName = new HashMap<>();
   private final Set<SymbolV2> symbols = new HashSet<>();
 
-  public ScopeV2(ScopeV2 parent, Tree rootTree) {
+  public ScopeV2(@Nullable ScopeV2 parent, Tree rootTree) {
     this.parent = parent;
     this.rootTree = rootTree;
     this.childrenScopes = new ArrayList<>();

python-frontend/src/main/java/org/sonar/python/semantic/v2/ScopeVisitor.java

@@ -0,0 +1,64 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * 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 GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.semantic.v2;
+
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.Map;
+import javax.annotation.Nullable;
+import org.sonar.plugins.python.api.tree.BaseTreeVisitor;
+import org.sonar.plugins.python.api.tree.Tree;
+
+public class ScopeVisitor extends BaseTreeVisitor {
+
+  private final Map<Tree, ScopeV2> scopesByRootTree;
+  private final Deque<Tree> scopeRootTrees;
+
+  public ScopeVisitor(Map<Tree, ScopeV2> scopesByRootTree) {
+    this.scopesByRootTree = scopesByRootTree;
+    this.scopeRootTrees = new LinkedList<>();
+  }
+
+  Tree currentScopeRootTree() {
+    return scopeRootTrees.peek();
+  }
+
+  void enterScope(Tree tree) {
+    scopeRootTrees.push(tree);
+  }
+
+  Tree leaveScope() {
+    return scopeRootTrees.pop();
+  }
+
+  ScopeV2 currentScope() {
+    return scopesByRootTree.get(currentScopeRootTree());
+  }
+
+  void createScope(Tree tree, @Nullable ScopeV2 parent) {
+    scopesByRootTree.put(tree, new ScopeV2(parent, tree));
+  }
+
+  void createAndEnterScope(Tree tree, @Nullable ScopeV2 parent) {
+    createScope(tree, parent);
+    enterScope(tree);
+  }
+
+}