SONARPY-3634 Resolve type when imported twice (#826)

GitOrigin-RevId: 5baae177e4f15587baef0991bdbb7f0fc8178c45

Author: Seppli11

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

@@ -44,7 +44,6 @@
 import org.sonar.python.index.VariableDescriptor;
 
 public class PythonTypeToDescriptorConverter {
-
   public Descriptor convert(String moduleFqn, SymbolV2 symbol, Set<PythonType> types) {
     var candidates = types.stream()
       .map(type -> convert(moduleFqn, moduleFqn, symbol.name(), type, symbol.usages()))
@@ -227,7 +226,7 @@ private static boolean usagesContainAssignment(List<UsageV2> symbolUsages) {
   private static TypeAnnotationDescriptor createTypeAnnotationDescriptor(PythonType type, boolean isSelf) {
     if (type instanceof SelfType selfType) {
       return createTypeAnnotationDescriptor(selfType.innerType(), isSelf);
-    }else if (type instanceof ClassType classType) {
+    } else if (type instanceof ClassType classType) {
       return new TypeAnnotationDescriptor(classType.name(), TypeAnnotationDescriptor.TypeKind.INSTANCE, List.of(), classType.fullyQualifiedName(), isSelf);
     } else if (type instanceof FunctionType functionType) {
       return new TypeAnnotationDescriptor(functionType.name(), TypeAnnotationDescriptor.TypeKind.CALLABLE, List.of(), functionType.fullyQualifiedName(), false);

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

@@ -865,32 +865,30 @@ public void visitName(Name name) {
       return;
     }
 
-    var bindingUsages = new ArrayList<UsageV2>();
-    for (var usage : symbolV2.usages()) {
-      if (usage.kind().equals(UsageV2.Kind.GLOBAL_DECLARATION)) {
-        // Don't infer type for global variables
-        return;
-      }
-      if (usage.isBindingUsage()) {
-        bindingUsages.add(usage);
-      }
-      if (bindingUsages.size() > 1) {
-        // no need to iterate over usages if there is more than one binding usage
-        return;
-      }
+    var bindingUsages = symbolV2.usages().stream()
+      .filter(UsageV2::isBindingUsage)
+      .toList();
+
+    boolean multipleBindingUsages = bindingUsages.size() > 1;
+    boolean onlyImportUsages = bindingUsages.stream().allMatch(usage -> UsageV2.Kind.IMPORT.equals(usage.kind()));
+    boolean hasGlobalStatementUsage = symbolV2.usages().stream().anyMatch(usage -> UsageV2.Kind.GLOBAL_DECLARATION.equals(usage.kind()));
+
+    if (hasGlobalStatementUsage || (multipleBindingUsages && !onlyImportUsages)) {
+      return;
     }
 
-    bindingUsages.stream()
-      .findFirst()
-      .filter(UsageV2::isBindingUsage)
+    var types = bindingUsages.stream()
       .map(UsageV2::tree)
-      .filter(Expression.class::isInstance)
-      .map(Expression.class::cast)
+      .flatMap(TreeUtils.toStreamInstanceOfMapper(Expression.class))
       .map(Expression::typeV2)
       // TODO: classes (SONARPY-1829) and functions should be propagated like other types
       .filter(t -> shouldTypeBeEagerlyPropagated(t, name))
-      .ifPresent(type -> setTypeToName(name, type));
+      .distinct()
+      .toList();
 
+    if (types.size() == 1) {
+      setTypeToName(name, types.get(0));
+    }
   }
 
   private boolean shouldTypeBeEagerlyPropagated(PythonType t, Name name) {

python-frontend/src/test/java/org/sonar/python/semantic/v2/TypeInferenceV2Test.java

@@ -1361,6 +1361,20 @@ def nested():
     assertThat(symbolV2.usages()).extracting(UsageV2::kind).containsExactlyInAnyOrder(UsageV2.Kind.ASSIGNMENT_LHS, UsageV2.Kind.GLOBAL_DECLARATION, UsageV2.Kind.OTHER);
   }
 
+  @Test
+  void global_variable_not_eagerly_propagated() {
+    FileInput fileInput = inferTypes("""
+      a = object()
+      def foo():
+        global a
+
+        a
+      """);
+    FunctionDef foo = PythonTestUtils.getFirstDescendant(fileInput, FunctionDef.class::isInstance);
+    Name aName = PythonTestUtils.getLastDescendant(foo.body(), Name.class::isInstance);
+    assertThat(aName.typeV2()).isEqualTo(PythonType.UNKNOWN);
+  }
+
   @Test
   void nonlocal_variable_in_nested_function() {
     FileInput fileInput = inferTypes("""
@@ -3345,6 +3359,76 @@ void import_unknown_httpx_client() {
     assertThat(statement.typeV2()).isEqualTo(PythonType.UNKNOWN);
   }
 
+  @Test
+  void duplicate_imports_in_from_import() {
+    var requestExpr = lastExpression("""
+      from flask import request, request
+      def test():
+        request
+      """);
+
+    PythonType requestType = PROJECT_LEVEL_TYPE_TABLE.getType("flask.request");
+    assertThat(requestType).isNotEqualTo(PythonType.UNKNOWN);
+
+    assertThat(requestExpr.typeV2()).isEqualTo(requestType);
+  }
+
+  static Stream<Arguments> duplicateImportsNotUnknownSource() {
+    return Stream.of(
+      Arguments.argumentSet("Duplicate from-import",
+          """
+        from flask import request
+        from flask import request
+        def test():
+          request
+        """, PROJECT_LEVEL_TYPE_TABLE.getType("flask.request")),
+      Arguments.argumentSet("Duplicate import-statement", """
+        import flask
+        import flask
+        def test():
+          flask
+        """, PROJECT_LEVEL_TYPE_TABLE.getType("flask")));
+  }
+
+  @ParameterizedTest()
+  @MethodSource("duplicateImportsNotUnknownSource")
+  void duplicate_imports_not_unknown(String code, PythonType expectedType) {
+    assertThat(expectedType).isNotEqualTo(PythonType.UNKNOWN);
+    assertThat(lastExpression(code).typeV2()).isEqualTo(expectedType);
+  }
+
+  static Stream<Arguments> duplicateImportsUnknownSource() {
+    return Stream.of(
+      Arguments.argumentSet("Duplicate from-import with different types",
+        """
+        if PY3:
+            from io import StringIO
+        else:
+            from cStringIO import StringIO
+        def test():
+          StringIO
+        """),
+      Arguments.argumentSet("Duplicate from-import with additional unrelated binding",
+        """
+        from flask import request, request
+        request = 1
+        def test():
+          request
+        """),
+      Arguments.argumentSet("Duplicate import-statement with additional unrelated binding", """
+        import flask
+        flask = 1
+        def test():
+          flask
+        """));
+  }
+
+  @ParameterizedTest
+  @MethodSource("duplicateImportsUnknownSource")
+  void duplicate_imports_unknown(String code) {
+    assertThat(lastExpression(code).typeV2()).isEqualTo(PythonType.UNKNOWN);
+  }
+
   @Test
   void returnTypeOfTypeshedSymbol() {
     FileInput fileInput = inferTypes("""