SONARPY-205 SelfAssignmentCheck: fix FP on imported name

Author: pynicolas

python-checks/src/main/java/org/sonar/python/checks/SelfAssignmentCheck.java

@@ -19,46 +19,81 @@
  */
 package org.sonar.python.checks;
 
+import com.google.common.collect.ImmutableSet;
+import com.sonar.sslr.api.AstNode;
+import com.sonar.sslr.api.AstNodeType;
+import java.util.HashSet;
 import java.util.Set;
-
 import org.sonar.check.Rule;
 import org.sonar.python.PythonCheck;
 import org.sonar.python.api.PythonGrammar;
+import org.sonar.python.api.PythonKeyword;
 import org.sonar.python.api.PythonPunctuator;
 import org.sonar.sslr.ast.AstSelect;
 
-import com.google.common.collect.ImmutableSet;
-import com.sonar.sslr.api.AstNode;
-import com.sonar.sslr.api.AstNodeType;
-
 @Rule(key = SelfAssignmentCheck.CHECK_KEY)
 public class SelfAssignmentCheck extends PythonCheck {
 
   public static final String CHECK_KEY = "S1656";
 
   public static final String MESSAGE = "Remove or correct this useless self-assignment.";
 
+  private Set<String> importedNames = new HashSet<>();
+
+  @Override
+  public void visitFile(AstNode node) {
+    importedNames.clear();
+  }
+
   @Override
   public Set<AstNodeType> subscribedKinds() {
-    return ImmutableSet.of(PythonGrammar.EXPRESSION_STMT);
+    return ImmutableSet.of(
+      PythonGrammar.EXPRESSION_STMT,
+      PythonGrammar.IMPORT_NAME,
+      PythonGrammar.IMPORT_AS_NAME);
   }
 
   @Override
   public void visitNode(AstNode node) {
-    for (AstNode assignOperator : node.getChildren(PythonPunctuator.ASSIGN)) {
-      if (CheckUtils.equalNodes(assignOperator.getPreviousSibling(), assignOperator.getNextSibling()) && !isException(node)) {
-        addIssue(assignOperator, MESSAGE);
+    if (node.is(PythonGrammar.IMPORT_NAME)) {
+      for (AstNode dottedAsName : node.select().children(PythonGrammar.DOTTED_AS_NAMES).children(PythonGrammar.DOTTED_AS_NAME)) {
+        AstNode importedName = dottedAsName.getFirstChild().getLastChild(PythonGrammar.NAME);
+        addImportedName(dottedAsName, importedName);
+      }
+
+    } else if (node.is(PythonGrammar.IMPORT_AS_NAME)) {
+      AstNode importedName = node.getFirstChild(PythonGrammar.NAME);
+      addImportedName(node, importedName);
+
+    } else {
+      for (AstNode assignOperator : node.getChildren(PythonPunctuator.ASSIGN)) {
+        AstNode assigned = assignOperator.getPreviousSibling();
+        if (CheckUtils.equalNodes(assigned, assignOperator.getNextSibling()) && !isException(node, assigned)) {
+          addIssue(assignOperator, MESSAGE);
+        }
       }
     }
   }
 
-  private static boolean isException(AstNode expressionStatement) {
-    AstSelect potentialFunctionCalls = expressionStatement.select()
+  private void addImportedName(AstNode node, AstNode importedName) {
+    AstNode name = importedName;
+    AstNode as = node.getFirstChild(PythonKeyword.AS);
+    if (as != null) {
+      name = as.getNextSibling();
+    }
+    importedNames.add(name.getTokenValue());
+  }
+
+  private boolean isException(AstNode expressionStatement, AstNode assigned) {
+    AstSelect potentialFunctionCalls = assigned.select()
       .descendants(PythonGrammar.TRAILER)
       .children(PythonPunctuator.LPARENTHESIS);
     if (!potentialFunctionCalls.isEmpty()) {
       return true;
     }
+    if (assigned.getTokens().size() == 1 && importedNames.contains(assigned.getTokenValue())) {
+      return true;
+    }
     AstNode suite = expressionStatement.getFirstAncestor(PythonGrammar.SUITE);
     return suite != null && suite.getParent().is(PythonGrammar.CLASSDEF, PythonGrammar.TRY_STMT);
   }

python-checks/src/test/resources/checks/selfAssignment.py

@@ -1,3 +1,6 @@
+import import1, x as import2
+from module1 import (import3, x as import4)
+
 x = 1
 x = y
 x = x # Noncompliant
@@ -21,3 +24,8 @@ def f():
 a.x = a.x # Noncompliant
 a[x] = a[x] # Noncompliant
 a[sideEffect()] = a[sideEffect()]
+
+import1 = import1
+import2 = import2
+import3 = import3
+import4 = import4