SONARPY-2165 Implement AmbiguousDescriptorToPythonTypeConverter

Author: ghislainpiot

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

@@ -0,0 +1,42 @@
+/*
+ * 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.stream.Collectors;
+import org.sonar.python.index.AmbiguousDescriptor;
+import org.sonar.python.index.Descriptor;
+import org.sonar.python.types.v2.PythonType;
+import org.sonar.python.types.v2.UnionType;
+
+public class AmbiguousDescriptorToPythonTypeConverter implements DescriptorToPythonTypeConverter {
+
+  public PythonType convert(ConversionContext ctx, AmbiguousDescriptor from) {
+    var candidates = from.alternatives().stream().map(ctx::convert).collect(Collectors.toSet());
+    return new UnionType(candidates);
+  }
+
+  @Override
+  public PythonType convert(ConversionContext ctx, Descriptor from) {
+    if (from instanceof AmbiguousDescriptor ambiguousDescriptor) {
+      return convert(ctx, ambiguousDescriptor);
+    }
+    throw new IllegalArgumentException("Unsupported Descriptor");
+  }
+}

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

@@ -36,7 +36,8 @@ public AnyDescriptorToPythonTypeConverter(LazyTypesContext lazyTypesContext) {
     converters = new EnumMap<>(Map.of(
       Descriptor.Kind.CLASS, new ClassDescriptorToPythonTypeConverter(),
       Descriptor.Kind.FUNCTION, new FunctionDescriptorToPythonTypeConverter(),
-      Descriptor.Kind.VARIABLE, new VariableDescriptorToPythonTypeConverter()
+      Descriptor.Kind.VARIABLE, new VariableDescriptorToPythonTypeConverter(),
+      Descriptor.Kind.AMBIGUOUS, new AmbiguousDescriptorToPythonTypeConverter()
     ));
   }
 

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

@@ -0,0 +1,38 @@
+/*
+ * 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 AmbiguousDescriptorToPythonTypeConverterTest {
+  @Test
+  void unsupportedClassTest() {
+    var ctx = Mockito.mock(ConversionContext.class);
+    var descriptor = Mockito.mock(ClassDescriptor.class);
+    var converter = new AmbiguousDescriptorToPythonTypeConverter();
+    Assertions.assertThatThrownBy(() -> converter.convert(ctx, descriptor))
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("Unsupported Descriptor");
+  }
+
+}

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

@@ -20,6 +20,7 @@
 package org.sonar.python.semantic.v2.converter;
 
 import java.util.List;
+import java.util.Set;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
@@ -37,8 +38,10 @@
 import org.sonar.python.types.v2.LazyTypeWrapper;
 import org.sonar.python.types.v2.Member;
 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.TypeWrapper;
+import org.sonar.python.types.v2.UnionType;
 
 class DescriptorToPythonTypeConverterTest {
 
@@ -56,11 +59,59 @@ void unknownDescriptorToPythonTypeConverterTest() {
   void ambiguousDescriptorConversionTest() {
     var lazyTypesContext = Mockito.mock(LazyTypesContext.class);
     var converter = new AnyDescriptorToPythonTypeConverter(lazyTypesContext);
+
+    var descriptorAlternative1 = Mockito.mock(FunctionDescriptor.class);
+
+    var returnTypeName = "Returned";
+    var resolvedReturnType = new ClassTypeBuilder().withName(returnTypeName).build();
+    Mockito.when(lazyTypesContext.resolveLazyType(Mockito.argThat(lt -> returnTypeName.equals(lt.fullyQualifiedName()))))
+      .thenReturn(resolvedReturnType);
+
+    Mockito.when(descriptorAlternative1.kind()).thenReturn(Descriptor.Kind.FUNCTION);
+    Mockito.when(descriptorAlternative1.name()).thenReturn("Sample");
+    Mockito.when(descriptorAlternative1.annotatedReturnTypeName()).thenReturn(returnTypeName);
+    Mockito.when(descriptorAlternative1.parameters()).thenReturn(List.of(
+      new FunctionDescriptor.Parameter(
+        "p1",
+        "Returned",
+        false,
+        false,
+        true,
+        false,
+        false,
+        new LocationInFile("m1", 1, 10,  1, 15))
+    ));
+
+    var descriptorAlternative2 = Mockito.mock(FunctionDescriptor.class);
+    Mockito.when(descriptorAlternative2.kind()).thenReturn(Descriptor.Kind.FUNCTION);
+    Mockito.when(descriptorAlternative2.name()).thenReturn("Sample");
+    Mockito.when(descriptorAlternative2.annotatedReturnTypeName()).thenReturn(returnTypeName);
+    Mockito.when(descriptorAlternative2.parameters()).thenReturn(List.of(
+      new FunctionDescriptor.Parameter(
+        "p2",
+        "Returned",
+        false,
+        false,
+        true,
+        false,
+        false,
+        new LocationInFile("m1", 2, 10,  2, 15))
+    ));
+
     var descriptor = Mockito.mock(AmbiguousDescriptor.class);
     Mockito.when(descriptor.kind()).thenReturn(Descriptor.Kind.AMBIGUOUS);
+    Mockito.when(descriptor.alternatives()).thenReturn(Set.of(descriptorAlternative1, descriptorAlternative2));
+
+    var type = (UnionType) converter.convert(descriptor);
+    Assertions.assertThat(type.candidates())
+      .hasSize(2);
+
+    Assertions.assertThat(type.candidates())
+      .extracting(FunctionType.class::cast)
+      .flatExtracting(FunctionType::parameters)
+      .extracting(ParameterV2::name)
+      .containsOnly("p1", "p2");
 
-    var type = converter.convert(descriptor);
-    Assertions.assertThat(type).isEqualTo(PythonType.UNKNOWN);
   }
 
   @Test