SONARPY-2127 Implement ClassDescriptorToPythonTypeConverter (#1969)

Author: maksim-grebeniuk-sonarsource

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

@@ -64,15 +64,16 @@ public ClassTypeBuilder withDefinitionLocation(@Nullable LocationInFile definiti
     return this;
   }
 
-  public List<TypeWrapper> superClasses() {
-    return superClasses;
-  }
-
   public ClassTypeBuilder addSuperClass(PythonType type) {
     superClasses.add(new LazyTypeWrapper(type));
     return this;
   }
 
+  public ClassTypeBuilder addSuperClass(TypeWrapper typeWrapper) {
+    superClasses.add(typeWrapper);
+    return this;
+  }
+
   public ClassTypeBuilder withSuperClasses(PythonType... types) {
     Arrays.stream(types).forEach(this::addSuperClass);
     return this;

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

@@ -19,6 +19,7 @@
  */
 package org.sonar.python.semantic.v2.converter;
 
+import java.util.EnumMap;
 import java.util.Map;
 import org.sonar.python.index.Descriptor;
 import org.sonar.python.semantic.v2.LazyTypesContext;
@@ -32,7 +33,9 @@ public class AnyDescriptorToPythonTypeConverter {
 
   public AnyDescriptorToPythonTypeConverter(LazyTypesContext lazyTypesContext) {
     this.lazyTypesContext = lazyTypesContext;
-    converters = Map.of();
+    converters = new EnumMap<>(Map.of(
+      Descriptor.Kind.CLASS, new ClassDescriptorToPythonTypeConverter()
+    ));
   }
 
   public PythonType convert(Descriptor from) {

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

@@ -0,0 +1,58 @@
+/*
+ * 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.sonar.python.index.ClassDescriptor;
+import org.sonar.python.index.Descriptor;
+import org.sonar.python.semantic.v2.ClassTypeBuilder;
+import org.sonar.python.types.v2.LazyTypeWrapper;
+import org.sonar.python.types.v2.Member;
+import org.sonar.python.types.v2.PythonType;
+
+public class ClassDescriptorToPythonTypeConverter implements DescriptorToPythonTypeConverter {
+
+  private static PythonType convert(ConversionContext ctx, ClassDescriptor from) {
+    var typeBuilder = new ClassTypeBuilder()
+      .withName(from.name())
+      .withDefinitionLocation(from.definitionLocation());
+
+    from.superClasses().stream()
+      .map(fqn -> ctx.lazyTypesContext().getOrCreateLazyType(fqn))
+      .map(LazyTypeWrapper::new)
+      .forEach(typeBuilder::addSuperClass);
+
+    var type = typeBuilder.build();
+    ctx.pushParent(type);
+    from.members()
+      .stream()
+      .map(d -> new Member(d.name(), ctx.convert(d)))
+      .forEach(type.members()::add);
+    ctx.pollParent();
+    return type;
+  }
+
+  @Override
+  public PythonType convert(ConversionContext ctx, Descriptor from) {
+    if (from instanceof ClassDescriptor classDescriptor) {
+      return convert(ctx, classDescriptor);
+    }
+    throw new IllegalArgumentException("Unsupported Descriptor");
+  }
+}

python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/ClassDescriptorToPythonTypeConverterTest.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.FunctionDescriptor;
+
+class ClassDescriptorToPythonTypeConverterTest {
+  @Test
+  void unsupportedClassTest() {
+    var ctx = Mockito.mock(ConversionContext.class);
+    var descriptor = Mockito.mock(FunctionDescriptor.class);
+    var converter = new ClassDescriptorToPythonTypeConverter();
+    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

@@ -19,13 +19,20 @@
  */
 package org.sonar.python.semantic.v2.converter;
 
+import java.util.List;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import org.sonar.python.index.AmbiguousDescriptor;
+import org.sonar.python.index.ClassDescriptor;
 import org.sonar.python.index.Descriptor;
+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.LazyType;
+import org.sonar.python.types.v2.Member;
 import org.sonar.python.types.v2.PythonType;
+import org.sonar.python.types.v2.TypeWrapper;
 
 class DescriptorToPythonTypeConverterTest {
 
@@ -50,6 +57,44 @@ void ambiguousDescriptorConversionTest() {
     Assertions.assertThat(type).isEqualTo(PythonType.UNKNOWN);
   }
 
+  @Test
+  void classDescriptorConversionTest() {
+    var lazyTypesContext = Mockito.mock(LazyTypesContext.class);
+    var converter = new AnyDescriptorToPythonTypeConverter(lazyTypesContext);
+    var descriptor = Mockito.mock(ClassDescriptor.class);
+
+    var parentClassName = "Parent";
+    var resolvedParent = new ClassTypeBuilder().withName(parentClassName).build();
+
+    var member = Mockito.mock(AmbiguousDescriptor.class);
+    Mockito.when(member.kind()).thenReturn(Descriptor.Kind.AMBIGUOUS);
+    Mockito.when(member.name()).thenReturn("member");
+
+    Mockito.when(descriptor.kind()).thenReturn(Descriptor.Kind.CLASS);
+    Mockito.when(descriptor.name()).thenReturn("Sample");
+    Mockito.when(descriptor.superClasses()).thenReturn(List.of(parentClassName));
+    Mockito.when(descriptor.members()).thenReturn(List.of(
+      member
+    ));
+    Mockito.when(lazyTypesContext.getOrCreateLazyType(parentClassName))
+      .thenReturn(new LazyType(parentClassName, lazyTypesContext));
+
+    Mockito.when(lazyTypesContext.resolveLazyType(Mockito.argThat(lt -> parentClassName.equals(lt.fullyQualifiedName()))))
+      .thenReturn(resolvedParent);
+
+    var type = (ClassType) converter.convert(descriptor);
+    Assertions.assertThat(type.name()).isEqualTo("Sample");
+    
+    Assertions.assertThat(type.superClasses())
+      .extracting(TypeWrapper.class::cast)
+      .extracting(TypeWrapper::type)
+      .containsOnly(resolvedParent);
+
+    Assertions.assertThat(type.members())
+      .extracting(Member::name)
+      .containsOnly("member");
+  }
+
 
 
 }