SONARPY-2124 Ensure parameters types of imported project functions have their declared type populated. (#1972)

Author: ghislainpiot

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

@@ -49,8 +49,8 @@
 import org.sonar.python.types.v2.ObjectType;
 import org.sonar.python.types.v2.ParameterV2;
 import org.sonar.python.types.v2.PythonType;
-import org.sonar.python.types.v2.SimpleTypeWrapper;
 import org.sonar.python.types.v2.TypeOrigin;
+import org.sonar.python.types.v2.TypeWrapper;
 import org.sonar.python.types.v2.UnionType;
 
 public class SymbolsModuleTypeProvider {
@@ -121,7 +121,7 @@ private PythonType convertToFunctionType(FunctionSymbol symbol, Map<Symbol, Pyth
 
     var parameters = symbol.parameters()
       .stream()
-      .map(SymbolsModuleTypeProvider::convertParameter)
+      .map(this::convertParameter)
       .toList();
 
     var returnType = getReturnTypeFromSymbol(symbol);
@@ -209,15 +209,19 @@ private PythonType convertToClassType(ClassSymbol symbol, Map<Symbol, PythonType
     return classType;
   }
 
-  private static ParameterV2 convertParameter(FunctionSymbol.Parameter parameter) {
+  private ParameterV2 convertParameter(FunctionSymbol.Parameter parameter) {
+    var typeWrapper = Optional.ofNullable(((FunctionSymbolImpl.ParameterImpl) parameter).annotatedTypeName())
+      .map(lazyTypesContext::getOrCreateLazyTypeWrapper)
+      .orElse(TypeWrapper.UNKNOWN_TYPE_WRAPPER);
+
     return new ParameterV2(parameter.name(),
-      new SimpleTypeWrapper(PythonType.UNKNOWN),
+      typeWrapper,
       parameter.hasDefaultValue(),
       parameter.isKeywordOnly(),
       parameter.isPositionalOnly(),
       parameter.isKeywordVariadic(),
       parameter.isPositionalVariadic(),
-      null);
+      parameter.location());
   }
 
   private PythonType convertToUnionType(AmbiguousSymbol ambiguousSymbol, Map<Symbol, PythonType> createdTypesBySymbol) {

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

@@ -22,4 +22,6 @@
 public interface TypeWrapper {
 
   PythonType type();
+
+  TypeWrapper UNKNOWN_TYPE_WRAPPER = new SimpleTypeWrapper(PythonType.UNKNOWN);
 }

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

@@ -31,6 +31,7 @@
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
+import org.sonar.plugins.python.api.LocationInFile;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.symbols.ClassSymbol;
 import org.sonar.plugins.python.api.symbols.Symbol;
@@ -54,6 +55,7 @@
 import org.sonar.python.PythonTestUtils;
 import org.sonar.python.semantic.ClassSymbolImpl;
 import org.sonar.python.semantic.ProjectLevelSymbolTable;
+import org.sonar.python.semantic.SymbolUtils;
 import org.sonar.python.tree.ExpressionStatementImpl;
 import org.sonar.python.tree.TreeUtils;
 import org.sonar.python.types.v2.ClassType;
@@ -694,6 +696,38 @@ def foo(param: my_alias): ...
     assertThat(((FunctionType) functionDef.name().typeV2()).parameters().get(0).declaredType().type().unwrappedType()).isEqualTo(PythonType.UNKNOWN);
   }
 
+  @Test
+  void inferFunctionParameterTypesMultiFile() {
+    FileInput tree = parseWithoutSymbols(
+      "def foo(param1: int): ...",
+      "class A: ...",
+      "def foo2(p1: dict, p2: A): ..."
+    );
+    ProjectLevelSymbolTable projectLevelSymbolTable = new ProjectLevelSymbolTable();
+    var modFile = pythonFile("mod.py");
+    projectLevelSymbolTable.addModule(tree, "", modFile);
+    ProjectLevelTypeTable projectLevelTypeTable = new ProjectLevelTypeTable(projectLevelSymbolTable);
+    var modFileId = SymbolUtils.pathOf(modFile).toString();
+
+    var intType = projectLevelTypeTable.lazyTypesContext().getOrCreateLazyType("int").resolve();
+    var dictType = projectLevelTypeTable.lazyTypesContext().getOrCreateLazyType("dict").resolve();
+    var aType = projectLevelTypeTable.lazyTypesContext().getOrCreateLazyType("mod.A").resolve();
+    var lines = """
+      from mod import foo, foo2
+      foo
+      foo2
+      """;
+    FileInput fileInput = inferTypes(lines, projectLevelTypeTable);
+    FunctionType fooType = (FunctionType) ((ExpressionStatement) fileInput.statements().statements().get(1)).expressions().get(0).typeV2();
+    assertThat(fooType.parameters().get(0).declaredType().type().unwrappedType()).isEqualTo(intType);
+
+    FunctionType foo2Type = (FunctionType) ((ExpressionStatement) fileInput.statements().statements().get(2)).expressions().get(0).typeV2();
+    assertThat(foo2Type.parameters()).extracting(ParameterV2::declaredType).extracting(TypeWrapper::type).containsExactly(dictType, aType);
+    assertThat(foo2Type.parameters()).extracting(ParameterV2::location).containsExactly(
+      new LocationInFile(modFileId, 3, 9, 3, 17),
+      new LocationInFile(modFileId, 3, 19, 3, 24));
+  }
+
   @Test
   void inferFunctionReturnTypeType() {
     FileInput root = inferTypes("""