Small Propagation refactoring

Author: Seppli11

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

@@ -16,27 +16,18 @@
  */
 package org.sonar.python.semantic.v2.types;
 
-import java.util.Map;
-import java.util.Set;
 import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.python.semantic.v2.SymbolV2;
 import org.sonar.python.types.v2.PythonType;
 
 public class Assignment extends Propagation {
 
-  Expression rhs;
-  Map<SymbolV2, Set<Propagation>> propagationsByLhs;
+  private Expression rhs;
 
-  public Assignment(SymbolV2 lhsSymbol, Name lhsName, Expression rhs, Map<SymbolV2, Set<Propagation>> propagationsByLhs) {
+  public Assignment(SymbolV2 lhsSymbol, Name lhsName, Expression rhs) {
     super(lhsSymbol, lhsName);
     this.rhs = rhs;
-    this.propagationsByLhs = propagationsByLhs;
-  }
-
-
-  public Name lhsName() {
-    return lhsName;
   }
 
   @Override

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

@@ -141,7 +141,7 @@ public boolean propagate(Propagation propagation, Set<SymbolV2> initializedVars)
 
     private void propagateTypeToUsages(Propagation propagation, PythonType newType) {
       Tree scopeTree = propagation.scopeTree(propagation.lhsName());
-      getSymbolNonDeclarationUsageTrees(propagation.lhsSymbol)
+      getSymbolNonDeclarationUsageTrees(propagation.lhsSymbol())
         .filter(NameImpl.class::isInstance)
         .map(NameImpl.class::cast)
         // Avoid propagation to usages in nested scopes, as this may lead to FPs

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

@@ -32,17 +32,14 @@ public Definition(SymbolV2 symbol, Name name) {
     super(symbol, name);
   }
 
-  public Name lhsName() {
-    return lhsName;
-  }
 
   @Override
   public PythonType rhsType() {
-    return lhsName.typeV2();
+    return lhsName().typeV2();
   }
 
   @Override
   Tree scopeTree(Name name) {
-    return TreeUtils.firstAncestor(name, t -> !t.equals(lhsName.parent()) && t.is(Tree.Kind.FUNCDEF, Tree.Kind.FILE_INPUT, Tree.Kind.CLASSDEF));
+    return TreeUtils.firstAncestor(name, t -> !t.equals(lhsName().parent()) && t.is(Tree.Kind.FUNCDEF, Tree.Kind.FILE_INPUT, Tree.Kind.CLASSDEF));
   }
 }

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

@@ -180,7 +180,7 @@ private void handleDefinitions(Statement definitionStatement, TypeInferenceProgr
       .ifPresent(definitions -> definitions.forEach(d -> {
         SymbolV2 symbol = d.lhsSymbol();
         if (trackedVars.contains(symbol)) {
-          programState.setTypes(symbol, Set.of(d.lhsName.typeV2()));
+          programState.setTypes(symbol, Set.of(d.lhsName().typeV2()));
         }
       }));
   }

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

@@ -17,9 +17,7 @@
 package org.sonar.python.semantic.v2.types;
 
 import java.util.Collection;
-import java.util.Map;
 import java.util.Optional;
-import java.util.Set;
 import java.util.stream.Stream;
 import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.plugins.python.api.tree.Name;
@@ -29,8 +27,8 @@
 import org.sonar.python.types.v2.TriBool;
 
 public class LoopAssignment extends Assignment {
-  public LoopAssignment(SymbolV2 lhsSymbol, Name lhsName, Expression rhs, Map<SymbolV2, Set<Propagation>> propagationsByLhs) {
-    super(lhsSymbol, lhsName, rhs, propagationsByLhs);
+  public LoopAssignment(SymbolV2 lhsSymbol, Name lhsName, Expression rhs) {
+    super(lhsSymbol, lhsName, rhs);
   }
 
   @Override

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

@@ -26,10 +26,6 @@ protected ParameterDefinition(SymbolV2 lhsSymbol, Name lhsName) {
     super(lhsSymbol, lhsName);
   }
 
-  @Override
-  public Name lhsName() {
-    return lhsName;
-  }
 
   @Override
   public PythonType rhsType() {

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

@@ -25,12 +25,11 @@
 import org.sonar.python.types.v2.PythonType;
 
 public abstract class Propagation {
+  private final Set<SymbolV2> variableDependencies;
+  private final Set<Propagation> dependents;
 
-  final Set<SymbolV2> variableDependencies;
-  final Set<Propagation> dependents;
-
-  final SymbolV2 lhsSymbol;
-  final Name lhsName;
+  private final SymbolV2 lhsSymbol;
+  private final Name lhsName;
 
   protected Propagation(SymbolV2 lhsSymbol, Name lhsName) {
     this.lhsSymbol = lhsSymbol;
@@ -52,7 +51,9 @@ Set<Propagation> dependents() {
     return dependents;
   }
 
-  public abstract Name lhsName();
+  public Name lhsName() {
+    return lhsName;
+  }
 
   public abstract PythonType rhsType();
 

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

@@ -172,9 +172,9 @@ public void visitForStatement(ForStatement forStatement) {
             .findFirst()
             .filter(NameImpl.class::isInstance)
             .map(NameImpl.class::cast)
-            .ifPresent(i -> {
-              var symbol = i.symbolV2();
-              var assignment = new LoopAssignment(symbol, i, rhsExpression, propagationsByLhs);
+            .ifPresent(name -> {
+              var symbol = name.symbolV2();
+              var assignment = new LoopAssignment(symbol, name, rhsExpression);
               assignmentsByAssignmentStatement.put(forStatement, assignment);
               propagationsByLhs.computeIfAbsent(symbol, s -> new HashSet<>()).add(assignment);
             })
@@ -191,7 +191,7 @@ private void processAssignment(Statement assignmentStatement, Expression lhsExpr
       if (symbol == null) {
         return;
       }
-      var assignment = new Assignment(symbol, lhs, rhsExpression, propagationsByLhs);
+      var assignment = new Assignment(symbol, lhs, rhsExpression);
       assignmentsByAssignmentStatement.put(assignmentStatement, assignment);
       propagationsByLhs.computeIfAbsent(symbol, s -> new HashSet<>()).add(assignment);
     }