SONARPY-2128 Implement FunctionDescriptorToPythonTypeConverter (#1970)

Author: maksim-grebeniuk-sonarsource

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

@@ -39,6 +39,7 @@
 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 static org.sonar.python.tree.TreeUtils.locationInFile;
 
@@ -52,7 +53,7 @@ public class FunctionTypeBuilder implements TypeBuilder<FunctionType> {
   private boolean hasDecorators;
   private boolean isInstanceMethod;
   private PythonType owner;
-  private PythonType returnType = PythonType.UNKNOWN;
+  private TypeWrapper returnType = TypeWrapper.UNKNOWN_TYPE_WRAPPER;
   private TypeOrigin typeOrigin = TypeOrigin.STUB;
   private LocationInFile definitionLocation;
 
@@ -80,6 +81,11 @@ public FunctionTypeBuilder(String name) {
   public FunctionTypeBuilder() {
   }
 
+  public FunctionTypeBuilder withName(String name) {
+    this.name = name;
+    return this;
+  }
+
   public FunctionTypeBuilder withHasVariadicParameter(boolean hasVariadicParameter) {
     this.hasVariadicParameter = hasVariadicParameter;
     return this;
@@ -111,6 +117,11 @@ public FunctionTypeBuilder withInstanceMethod(boolean instanceMethod) {
   }
 
   public FunctionTypeBuilder withReturnType(PythonType returnType) {
+    withReturnType(new LazyTypeWrapper(returnType));
+    return this;
+  }
+
+  public FunctionTypeBuilder withReturnType(TypeWrapper returnType) {
     this.returnType = returnType;
     return this;
   }

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

@@ -42,13 +42,13 @@
 import org.sonar.python.types.protobuf.SymbolsProtos;
 import org.sonar.python.types.v2.ClassType;
 import org.sonar.python.types.v2.FunctionType;
-import org.sonar.python.types.v2.LazyType;
 import org.sonar.python.types.v2.LazyTypeWrapper;
 import org.sonar.python.types.v2.Member;
 import org.sonar.python.types.v2.ModuleType;
 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;
@@ -140,18 +140,16 @@ private PythonType convertToFunctionType(FunctionSymbol symbol, Map<Symbol, Pyth
         .withHasVariadicParameter(symbol.hasVariadicParameter())
         .withDefinitionLocation(symbol.definitionLocation());
     FunctionType functionType = functionTypeBuilder.build();
-    if (returnType instanceof LazyType lazyType) {
-      lazyType.addConsumer(functionType::resolveLazyReturnType);
-    }
     createdTypesBySymbol.put(symbol, functionType);
     return functionType;
   }
 
-  private PythonType getReturnTypeFromSymbol(FunctionSymbol symbol) {
+  private TypeWrapper getReturnTypeFromSymbol(FunctionSymbol symbol) {
     var returnTypeFqns = getReturnTypeFqn(symbol);
     var returnTypeList = returnTypeFqns.stream().map(lazyTypesContext::getOrCreateLazyTypeWrapper).map(ObjectType::new).toList();
     //TODO Support type unions (SONARPY-2132)
-    return returnTypeList.size() == 1 ? returnTypeList.get(0) : PythonType.UNKNOWN;
+    var type = returnTypeList.size() == 1 ? returnTypeList.get(0) : PythonType.UNKNOWN;
+    return new SimpleTypeWrapper(type);
   }
 
   PythonType resolvePossibleLazyType(String fullyQualifiedName) {

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

@@ -34,7 +34,8 @@ public class AnyDescriptorToPythonTypeConverter {
   public AnyDescriptorToPythonTypeConverter(LazyTypesContext lazyTypesContext) {
     this.lazyTypesContext = lazyTypesContext;
     converters = new EnumMap<>(Map.of(
-      Descriptor.Kind.CLASS, new ClassDescriptorToPythonTypeConverter()
+      Descriptor.Kind.CLASS, new ClassDescriptorToPythonTypeConverter(),
+      Descriptor.Kind.FUNCTION, new FunctionDescriptorToPythonTypeConverter()
     ));
   }
 

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

@@ -0,0 +1,80 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.semantic.v2.converter;
+
+import java.util.List;
+import java.util.Optional;
+import org.sonar.python.index.Descriptor;
+import org.sonar.python.index.FunctionDescriptor;
+import org.sonar.python.semantic.v2.FunctionTypeBuilder;
+import org.sonar.python.types.v2.ParameterV2;
+import org.sonar.python.types.v2.PythonType;
+import org.sonar.python.types.v2.TypeOrigin;
+
+public class FunctionDescriptorToPythonTypeConverter implements DescriptorToPythonTypeConverter {
+
+  private final ParameterConverter parameterConverter;
+
+  public FunctionDescriptorToPythonTypeConverter() {
+    parameterConverter = new ParameterConverter();
+  }
+
+  public PythonType convert(ConversionContext ctx, FunctionDescriptor from) {
+    var parameters = from.parameters()
+      .stream()
+      .map(parameter -> parameterConverter.convert(ctx, parameter))
+      .toList();
+
+    var returnType = Optional.ofNullable(from.annotatedReturnTypeName())
+      .map(fqn -> (PythonType) ctx.lazyTypesContext().getOrCreateLazyType(fqn))
+      .orElse(PythonType.UNKNOWN);
+
+    var typeOrigin = TypeOrigin.LOCAL;
+
+    var hasVariadicParameter = hasVariadicParameter(parameters);
+
+    var toBuilder = new FunctionTypeBuilder()
+      .withOwner(ctx.currentParent())
+      .withName(from.name())
+      .withParameters(parameters)
+      .withReturnType(returnType)
+      .withTypeOrigin(typeOrigin)
+      .withAsynchronous(from.isAsynchronous())
+      .withHasDecorators(from.hasDecorators())
+      .withInstanceMethod(from.isInstanceMethod())
+      .withHasVariadicParameter(hasVariadicParameter)
+      .withDefinitionLocation(from.definitionLocation());
+
+    return toBuilder.build();
+  }
+
+  private static boolean hasVariadicParameter(List<ParameterV2> parameters) {
+    return parameters.stream()
+      .anyMatch(p -> p.isKeywordVariadic() || p.isPositionalVariadic());
+  }
+
+  @Override
+  public PythonType convert(ConversionContext ctx, Descriptor from) {
+    if (from instanceof FunctionDescriptor functionDescriptor) {
+      return convert(ctx, functionDescriptor);
+    }
+    throw new IllegalArgumentException("Unsupported Descriptor");
+  }
+}

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

@@ -0,0 +1,51 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.semantic.v2.converter;
+
+import java.util.Optional;
+import org.sonar.python.index.FunctionDescriptor;
+import org.sonar.python.types.v2.LazyTypeWrapper;
+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.TypeWrapper;
+
+public class ParameterConverter {
+
+  public ParameterV2 convert(ConversionContext ctx, FunctionDescriptor.Parameter parameter) {
+    var typeWrapper = Optional.ofNullable(parameter.annotatedType())
+      .map(fqn -> (PythonType) ctx.lazyTypesContext().getOrCreateLazyType(fqn))
+      .map(lt -> (TypeWrapper) new LazyTypeWrapper(lt))
+      .orElseGet(() -> new SimpleTypeWrapper(PythonType.UNKNOWN));
+
+    var type = new ObjectType(typeWrapper);
+
+    return new ParameterV2(parameter.name(),
+      new SimpleTypeWrapper(type),
+      parameter.hasDefaultValue(),
+      parameter.isKeywordOnly(),
+      parameter.isPositionalOnly(),
+      parameter.isKeywordVariadic(),
+      parameter.isPositionalVariadic(),
+      parameter.location());
+  }
+
+}

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

@@ -34,7 +34,7 @@ public final class FunctionType implements PythonType {
   private final String name;
   private final List<PythonType> attributes;
   private final List<ParameterV2> parameters;
-  private PythonType returnType;
+  private TypeWrapper returnType;
   private final TypeOrigin typeOrigin;
   private final boolean isAsynchronous;
   private final boolean hasDecorators;
@@ -50,7 +50,7 @@ public FunctionType(
     String name,
     List<PythonType> attributes,
     List<ParameterV2> parameters,
-    PythonType returnType,
+    TypeWrapper returnType,
     TypeOrigin typeOrigin,
     boolean isAsynchronous,
     boolean hasDecorators,
@@ -101,7 +101,7 @@ public List<ParameterV2> parameters() {
   }
 
   public PythonType returnType() {
-    return TypeUtils.resolved(returnType);
+    return returnType.type();
   }
 
   public boolean isAsynchronous() {
@@ -125,13 +125,6 @@ public PythonType owner() {
     return owner;
   }
 
-  public void resolveLazyReturnType(PythonType pythonType) {
-    if (!(returnType instanceof LazyType)) {
-      throw new IllegalStateException("Trying to resolve an already resolved lazy type.");
-    }
-    this.returnType = pythonType;
-  }
-
   public TypeOrigin typeOrigin() {
     return typeOrigin;
   }

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

@@ -61,6 +61,7 @@
 import org.sonar.python.types.v2.ClassType;
 import org.sonar.python.types.v2.FunctionType;
 import org.sonar.python.types.v2.LazyType;
+import org.sonar.python.types.v2.SimpleTypeWrapper;
 import org.sonar.python.types.v2.TypeWrapper;
 import org.sonar.python.types.v2.ModuleType;
 import org.sonar.python.types.v2.ObjectType;
@@ -436,7 +437,7 @@ void typeSourceIsExactByDefault() {
 
     CallExpression callExpressionSpy = Mockito.spy(callExpression);
     Expression calleeSpy = Mockito.spy(callExpression.callee());
-    FunctionType functionType = new FunctionType("foo", List.of(), List.of(), new ObjectType(INT_TYPE), TypeOrigin.STUB, false, false, false, false, null, null);
+    FunctionType functionType = new FunctionType("foo", List.of(), List.of(), new SimpleTypeWrapper(new ObjectType(INT_TYPE)), TypeOrigin.STUB, false, false, false, false, null, null);
     Mockito.when(calleeSpy.typeV2()).thenReturn(functionType);
     Mockito.when(callExpressionSpy.callee()).thenReturn(calleeSpy);
 
@@ -2273,9 +2274,6 @@ void resolvedTypingLazyType() {
     FunctionType functionType = ((FunctionType) ((ExpressionStatement) fileInput.statements().statements().get(1)).expressions().get(0).typeV2());
     PythonType returnType = functionType.returnType();
     assertThat(returnType.unwrappedType()).isInstanceOf(ClassType.class);
-    assertThatThrownBy(() -> functionType.resolveLazyReturnType(PythonType.UNKNOWN))
-      .isInstanceOf(IllegalStateException.class)
-      .hasMessage("Trying to resolve an already resolved lazy type.");
   }
 
   @Test

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

@@ -23,12 +23,15 @@
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
+import org.sonar.plugins.python.api.LocationInFile;
 import org.sonar.python.index.AmbiguousDescriptor;
 import org.sonar.python.index.ClassDescriptor;
 import org.sonar.python.index.Descriptor;
+import org.sonar.python.index.FunctionDescriptor;
 import org.sonar.python.semantic.v2.ClassTypeBuilder;
 import org.sonar.python.semantic.v2.LazyTypesContext;
 import org.sonar.python.types.v2.ClassType;
+import org.sonar.python.types.v2.FunctionType;
 import org.sonar.python.types.v2.LazyType;
 import org.sonar.python.types.v2.Member;
 import org.sonar.python.types.v2.PythonType;
@@ -95,6 +98,49 @@ void classDescriptorConversionTest() {
       .containsOnly("member");
   }
 
+  @Test
+  void functionDescriptorConversionTest() {
+    var lazyTypesContext = Mockito.mock(LazyTypesContext.class);
+    var converter = new AnyDescriptorToPythonTypeConverter(lazyTypesContext);
+    var descriptor = Mockito.mock(FunctionDescriptor.class);
+
+    var returnTypeName = "Returned";
+    var resolvedReturnType = new ClassTypeBuilder().withName(returnTypeName).build();
+
+    Mockito.when(descriptor.kind()).thenReturn(Descriptor.Kind.FUNCTION);
+    Mockito.when(descriptor.name()).thenReturn("Sample");
+    Mockito.when(descriptor.annotatedReturnTypeName()).thenReturn(returnTypeName);
+    Mockito.when(descriptor.parameters()).thenReturn(List.of(
+      new FunctionDescriptor.Parameter(
+        "p1",
+        "Returned",
+        false,
+        false,
+        true,
+        false,
+        false,
+        new LocationInFile("m1", 1, 10,  1, 15))
+    ));
+
+    Mockito.when(lazyTypesContext.getOrCreateLazyType(returnTypeName))
+      .thenReturn(new LazyType(returnTypeName, lazyTypesContext));
+
+    Mockito.when(lazyTypesContext.resolveLazyType(Mockito.argThat(lt -> returnTypeName.equals(lt.fullyQualifiedName()))))
+      .thenReturn(resolvedReturnType);
+
+    var type = (FunctionType) converter.convert(descriptor);
+    Assertions.assertThat(type.name()).isEqualTo("Sample");
+
+    Assertions.assertThat(type.parameters()).hasSize(1);
+    var parameter = type.parameters().get(0);
+    Assertions.assertThat(parameter.declaredType())
+      .extracting(TypeWrapper::type)
+      .extracting(PythonType::unwrappedType)
+      .isSameAs(resolvedReturnType);
+    Assertions.assertThat(type.returnType())
+      .extracting(PythonType::unwrappedType)
+      .isSameAs(resolvedReturnType);
+  }
 
 
 }

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

@@ -0,0 +1,37 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.semantic.v2.converter;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.sonar.python.index.ClassDescriptor;
+
+class FunctionDescriptorToPythonTypeConverterTest {
+  @Test
+  void unsupportedClassTest() {
+    var ctx = Mockito.mock(ConversionContext.class);
+    var descriptor = Mockito.mock(ClassDescriptor.class);
+    var converter = new FunctionDescriptorToPythonTypeConverter();
+    Assertions.assertThatThrownBy(() -> converter.convert(ctx, descriptor))
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("Unsupported Descriptor");
+  }
+}