SONARPY-3223 Serialize and deserialize typing.Self to and from protbuf stubs (#690)

GitOrigin-RevId: 7dbbfca4acb57d88082aac4015cc83644469cae8

Author: joke1196

python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/SelfType.java

@@ -43,10 +43,10 @@
  */
 @Beta
 public final class SelfType implements PythonType {
-  private final ClassType innerType;
+  private final TypeWrapper typeWrapper;
 
-  private SelfType(ClassType innerType) {
-    this.innerType = innerType;
+  private SelfType(TypeWrapper typeWrapper) {
+    this.typeWrapper = typeWrapper;
   }
 
   private static String formatWithBrackets(String prefix, String content) {
@@ -76,21 +76,21 @@ public static PythonType of(@Nullable PythonType type) {
     if (type == null || type == PythonType.UNKNOWN) {
       return PythonType.UNKNOWN;
     }
-    
+
     if (type instanceof SelfType) {
       return type;
     }
-    
+
     if (type instanceof ClassType classType) {
-      return new SelfType(classType);
+      return new SelfType(TypeWrapper.of(classType));
     }
-    
+
     if (type instanceof UnionType unionType) {
       return UnionType.or(unionType.candidates().stream()
         .map(SelfType::of)
         .toList());
     }
-    
+
     if (type instanceof ObjectType objectType) {
       PythonType unwrapped = objectType.unwrappedType();
       PythonType wrappedType = of(unwrapped);
@@ -102,82 +102,92 @@ public static PythonType of(@Nullable PythonType type) {
       }
       return PythonType.UNKNOWN;
     }
+    return PythonType.UNKNOWN;
+  }
 
+  public PythonType innerType() {
+    var type = typeWrapper.type();
+    if (type instanceof ClassType) {
+      return type;
+    }
     return PythonType.UNKNOWN;
   }
 
-  public ClassType innerType() {
-    return innerType;
+  public TypeWrapper typeWrapper() {
+    return typeWrapper;
   }
 
   @Override
   public String name() {
-    return formatAsSelf(innerType.name());
+    return formatAsSelf(typeWrapper.type().name());
   }
 
   @Override
   public Optional<String> displayName() {
-    return innerType.displayName()
+    return typeWrapper.type().displayName()
       .map(SelfType::formatAsSelf);
   }
 
   @Override
   public Optional<String> instanceDisplayName() {
-    return innerType.instanceDisplayName()
+    return typeWrapper.type().instanceDisplayName()
       .map(SelfType::formatAsSelf);
   }
 
   @Override
   public boolean isCompatibleWith(PythonType another) {
-    return innerType.isCompatibleWith(another);
+    return typeWrapper.type().isCompatibleWith(another);
   }
 
   @Override
   public String key() {
-    return formatAsSelf(innerType.key());
+    return formatAsSelf(typeWrapper.type().key());
   }
 
   @Override
   public Optional<PythonType> resolveMember(String memberName) {
-    return innerType.resolveMember(memberName);
+    return typeWrapper.type().resolveMember(memberName);
   }
 
   @Override
   public TriBool hasMember(String memberName) {
-    return innerType.hasMember(memberName);
+    return typeWrapper.type().hasMember(memberName);
   }
 
   @Override
   public Optional<LocationInFile> definitionLocation() {
-    return innerType.definitionLocation();
+    return typeWrapper.type().definitionLocation();
   }
 
   @Override
   public PythonType unwrappedType() {
-    return innerType.unwrappedType();
+    return typeWrapper.type().unwrappedType();
   }
 
   @Override
   public TypeSource typeSource() {
-    return innerType.typeSource();
+    return typeWrapper.type().typeSource();
   }
 
   @Override
   public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
     SelfType selfType = (SelfType) o;
-    return Objects.equals(innerType, selfType.innerType);
+    return Objects.equals(typeWrapper, selfType.typeWrapper);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(SelfType.class, innerType);
+    return Objects.hash(SelfType.class, typeWrapper);
   }
 
   @Override
   public String toString() {
-    return formatWithBrackets("SelfType", innerType.toString());
+    return formatWithBrackets("SelfType", typeWrapper.toString());
   }
 }
-

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

@@ -16,6 +16,7 @@
  */
 package org.sonar.python.semantic.v2.converter;
 
+import com.google.common.annotations.VisibleForTesting;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
@@ -116,13 +117,16 @@ private static Descriptor convert(String moduleFqn, FunctionType type) {
       type.hasDecorators(),
       type.definitionLocation().orElse(null),
       null,
-      null
-    );
+      null);
   }
 
-  private static Descriptor convert(String moduleFqn, String parentFqn, String symbolName, SelfType selfType) {
+  @VisibleForTesting
+  static Descriptor convert(String moduleFqn, String parentFqn, String symbolName, SelfType selfType) {
     var innerType = selfType.innerType();
-    return convert(moduleFqn, parentFqn, symbolName, innerType, true);
+    if (!(innerType instanceof ClassType classType)) {
+      throw new IllegalStateException("SelfType's innerType is not a ClassType " + selfType.name());
+    }
+    return convert(moduleFqn, parentFqn, symbolName, classType, true);
   }
 
   private static Descriptor convert(String moduleFqn, String parentFqn, String symbolName, ClassType type, boolean isSelf) {
@@ -171,15 +175,13 @@ private static Descriptor convert(String moduleFqn, String parentFqn, String sym
       .collect(Collectors.toSet());
     return new AmbiguousDescriptor(symbolName,
       symbolFqn(moduleFqn, symbolName),
-      candidates
-    );
+      candidates);
   }
 
   private static Descriptor convert(String parentFqn, String symbolName, UnknownType.UnresolvedImportType type) {
     return new VariableDescriptor(symbolName,
       symbolFqn(parentFqn, symbolName),
-      type.importPath()
-    );
+      type.importPath());
   }
 
   private static FunctionDescriptor.Parameter convert(String moduleFqn, ParameterV2 parameter) {

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

@@ -20,9 +20,10 @@
 import java.util.Set;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
+import org.sonar.plugins.python.api.types.v2.PythonType;
+import org.sonar.plugins.python.api.types.v2.SelfType;
 import org.sonar.python.index.TypeAnnotationDescriptor;
 import org.sonar.python.types.v2.LazyUnionType;
-import org.sonar.plugins.python.api.types.v2.PythonType;
 
 public class TypeAnnotationToPythonTypeConverter {
 
@@ -58,6 +59,13 @@ public PythonType convert(ConversionContext context, TypeAnnotationDescriptor ty
         // SONARPY-2179: This case only makes sense for parameter types, which are not supported yet
         return context.lazyTypesContext().getOrCreateLazyType("dict");
       case TYPE_VAR:
+        if(Boolean.TRUE.equals(type.isSelf())){
+          if(type.args().size() != 1){
+            return PythonType.UNKNOWN;
+          }
+          PythonType innerType = convert(context, type.args().get(0));
+          return SelfType.of(innerType);
+        }
         return Optional.of(type)
           .filter(TypeAnnotationToPythonTypeConverter::filterTypeVar)
           .map(TypeAnnotationDescriptor::fullyQualifiedName)
@@ -78,7 +86,6 @@ public PythonType convert(ConversionContext context, TypeAnnotationDescriptor ty
   public static boolean filterTypeVar(TypeAnnotationDescriptor type) {
     return Optional.of(type)
       // Filtering self returning methods until the SONARPY-1472 will be solved
-      .filter(Predicate.not(TypeAnnotationDescriptor::isSelf))
       .map(TypeAnnotationDescriptor::fullyQualifiedName)
       .filter(Predicate.not(String::isEmpty))
       // We ignore TypeVar referencing "builtins.object" or "object" to avoid false positives

python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/SelfTypeTest.java

@@ -189,6 +189,16 @@ void selfTypeOfObjectTypeWithAttributes() {
     assertThat(innerSelfType.innerType()).isEqualTo(classType);
   }
 
+  @Test
+  void selfTypetypeWrapper() {
+    ClassType classType = (ClassType) INT_TYPE;
+    SelfType selfType = (SelfType) SelfType.of(classType);
+
+    TypeWrapper wrappedType = selfType.typeWrapper();
+    assertThat(wrappedType).isNotNull();
+    assertThat(wrappedType.type()).isEqualTo(classType.unwrappedType());
+  }
+
   @Test
   void selfTypeOfUnionType() {
     ClassType classTypeA = (ClassType) INT_TYPE;

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

@@ -0,0 +1,69 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2025 SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ *
+ * 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 Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+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.TypeAnnotationDescriptor;
+import org.sonar.python.semantic.v2.LazyTypesContext;
+import org.sonar.plugins.python.api.types.v2.PythonType;
+
+class TypeAnnotationToPythonTypeConverterTest {
+
+  @Test
+  void typeVarWithIncorrectArgsAndIsSelfTrueReturnsUnknown() {
+    var lazyTypesContext = Mockito.mock(LazyTypesContext.class);
+    var ctx = Mockito.mock(ConversionContext.class);
+    var converter = new TypeAnnotationToPythonTypeConverter();
+
+    Mockito.when(ctx.lazyTypesContext()).thenReturn(lazyTypesContext);
+
+    // Create a TYPE_VAR TypeAnnotationDescriptor with isSelf=true and multiple args
+    var innerArg1 = new TypeAnnotationDescriptor("int", TypeAnnotationDescriptor.TypeKind.INSTANCE, List.of(), "int", false);
+    var innerArg2 = new TypeAnnotationDescriptor("str", TypeAnnotationDescriptor.TypeKind.INSTANCE, List.of(), "str", false);
+    var typeVarDescriptor = new TypeAnnotationDescriptor(
+      "TypeVar",
+      TypeAnnotationDescriptor.TypeKind.TYPE_VAR,
+      List.of(innerArg1, innerArg2),
+      "typing.TypeVar",
+      true
+    );
+
+    var result = converter.convert(ctx, typeVarDescriptor);
+
+    Assertions.assertThat(result)
+      .as("TYPE_VAR with isSelf=true and args.size() > 1 should return UNKNOWN")
+      .isEqualTo(PythonType.UNKNOWN);
+
+
+    // Create a TYPE_VAR TypeAnnotationDescriptor with isSelf=true and zero args
+     typeVarDescriptor = new TypeAnnotationDescriptor(
+      "TypeVar",
+      TypeAnnotationDescriptor.TypeKind.TYPE_VAR,
+      List.of(),
+      "typing.TypeVar",
+      true
+    );
+     result = converter.convert(ctx, typeVarDescriptor);
+
+    Assertions.assertThat(result)
+      .as("TYPE_VAR with isSelf=true and args.size() == 0 should return UNKNOWN")
+      .isEqualTo(PythonType.UNKNOWN);
+  }
+}