SONARPY-2022 Resolve type aliases types from TypeShed (#1906)

Author: guillaume-dequenne

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

@@ -20,6 +20,7 @@
 package org.sonar.python.semantic.v2;
 
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.stream.IntStream;
 import org.sonar.python.semantic.ProjectLevelSymbolTable;
@@ -31,6 +32,17 @@ public class ProjectLevelTypeTable {
   private final SymbolsModuleTypeProvider symbolsModuleTypeProvider;
   private final ModuleType rootModule;
   private final LazyTypesContext lazyTypesContext;
+  private final Map<String, Map<String, String>> aliasMembers = Map.ofEntries(
+    Map.entry("typing", Map.ofEntries(
+      Map.entry("List", "list"),
+      Map.entry("Tuple", "tuple"),
+      Map.entry("Dict", "dict"),
+      Map.entry("Set", "set"),
+      Map.entry("FrozenSet", "frozenset"),
+      Map.entry("Type", "type")
+    ))
+  );
+
 
   public ProjectLevelTypeTable(ProjectLevelSymbolTable projectLevelSymbolTable) {
     this(projectLevelSymbolTable, new TypeShed(projectLevelSymbolTable));
@@ -62,10 +74,13 @@ public PythonType getType(List<String> typeFqnParts) {
       if (resolvedMember.isPresent()) {
         parent = resolvedMember.get();
       } else if (parent instanceof ModuleType module) {
-        var moduleFqn = IntStream.rangeClosed(0, i)
+        var moduleFqnParts = IntStream.rangeClosed(0, i)
           .mapToObj(typeFqnParts::get)
           .toList();
-        parent = symbolsModuleTypeProvider.convertModuleType(moduleFqn, module);
+        parent = symbolsModuleTypeProvider.convertModuleType(moduleFqnParts, module);
+        if (parent instanceof ModuleType moduleType) {
+          addAliasMembers(moduleFqnParts, moduleType);
+        }
       } else {
         return PythonType.UNKNOWN;
       }
@@ -76,4 +91,15 @@ public PythonType getType(List<String> typeFqnParts) {
   public LazyTypesContext lazyTypesContext() {
     return lazyTypesContext;
   }
+
+  public void addAliasMembers(List<String> moduleFqnParts, ModuleType moduleType) {
+    String moduleFqn = String.join(".", moduleFqnParts);
+    aliasMembers.getOrDefault(moduleFqn, Map.of())
+      .forEach((memberName, alias) -> {
+        var pythonType = getType(alias);
+        if (pythonType != PythonType.UNKNOWN) {
+          moduleType.members().put(memberName, pythonType);
+        }
+      });
+  }
 }

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

@@ -68,12 +68,15 @@
 import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
 import static org.sonar.python.PythonTestUtils.parse;
 import static org.sonar.python.types.v2.TypesTestUtils.DICT_TYPE;
+import static org.sonar.python.types.v2.TypesTestUtils.FROZENSET_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.INT_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.LIST_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.NONE_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.PROJECT_LEVEL_TYPE_TABLE;
 import static org.sonar.python.types.v2.TypesTestUtils.SET_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.STR_TYPE;
+import static org.sonar.python.types.v2.TypesTestUtils.TUPLE_TYPE;
+import static org.sonar.python.types.v2.TypesTestUtils.TYPE_TYPE;
 
 class TypeInferenceV2Test {
 
@@ -1560,6 +1563,37 @@ def f():
       .isSameAs(PythonType.UNKNOWN);
   }
 
+  @Test
+  void typing_aliases_are_resolved_to_builtin_equivalent() {
+    var fileInput = inferTypes("""
+      import typing
+      a = typing.Tuple
+      a
+      b = typing.List
+      b
+      c = typing.Dict
+      c
+      d = typing.Set
+      d
+      e = typing.FrozenSet
+      e
+      f = typing.Type
+      f
+      """);
+    var aExpr = ((ExpressionStatement) fileInput.statements().statements().get(2)).expressions().get(0);
+    assertThat(aExpr.typeV2()).isEqualTo(TUPLE_TYPE);
+    var bExpr = ((ExpressionStatement) fileInput.statements().statements().get(4)).expressions().get(0);
+    assertThat(bExpr.typeV2()).isEqualTo(LIST_TYPE);
+    var cExpr = ((ExpressionStatement) fileInput.statements().statements().get(6)).expressions().get(0);
+    assertThat(cExpr.typeV2()).isEqualTo(DICT_TYPE);
+    var dExpr = ((ExpressionStatement) fileInput.statements().statements().get(8)).expressions().get(0);
+    assertThat(dExpr.typeV2()).isEqualTo(SET_TYPE);
+    var eExpr = ((ExpressionStatement) fileInput.statements().statements().get(10)).expressions().get(0);
+    assertThat(eExpr.typeV2()).isEqualTo(FROZENSET_TYPE);
+    var fExpr = ((ExpressionStatement) fileInput.statements().statements().get(12)).expressions().get(0);
+    assertThat(fExpr.typeV2()).isEqualTo(TYPE_TYPE);
+  }
+
   @Test
   void inferLoopOverNonIterableVarTypeInTry() {
     var root = inferTypes("""

python-frontend/src/test/java/org/sonar/python/types/v2/TypesTestUtils.java

@@ -36,9 +36,12 @@ public class TypesTestUtils {
   public static final PythonType BOOL_TYPE = BUILTINS.resolveMember("bool").get();
   public static final PythonType STR_TYPE = BUILTINS.resolveMember("str").get();
   public static final PythonType LIST_TYPE = BUILTINS.resolveMember("list").get();
+  public static final PythonType TUPLE_TYPE = BUILTINS.resolveMember("tuple").get();
   public static final PythonType SET_TYPE = BUILTINS.resolveMember("set").get();
+  public static final PythonType FROZENSET_TYPE = BUILTINS.resolveMember("frozenset").get();
   public static final PythonType DICT_TYPE = BUILTINS.resolveMember("dict").get();
   public static final PythonType NONE_TYPE = BUILTINS.resolveMember("NoneType").get();
+  public static final PythonType TYPE_TYPE = BUILTINS.resolveMember("type").get();
 
   public static FileInput parseAndInferTypes(String... code) {
     return parseAndInferTypes(PythonTestUtils.pythonFile(""), code);