SONARPY-4789 Model generic information for S6543

GitOrigin-RevId: 211a014b4566b2adff61a4e73b4209b10317ad15

Author: guillaume-dequenne

python-checks/src/main/java/org/sonar/python/checks/GenericTypeWithoutArgumentCheck.java

@@ -29,6 +29,7 @@
 import org.sonar.plugins.python.api.tree.SubscriptionExpression;
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.plugins.python.api.tree.TypeAnnotation;
+import org.sonar.plugins.python.api.types.v2.GenericInfo;
 import org.sonar.python.semantic.ClassSymbolImpl;
 import org.sonar.python.tree.NameImpl;
 
@@ -58,7 +59,7 @@ private static void checkForGenericTypeWithoutArgument(SubscriptionContext subsc
       return;
     }
 
-    if (typeSupportsGenericsOrIsACollection(expression) || qualifiedExpressionIsACollection(expression)) {
+    if (shouldReportMissingTypeArguments(expression) || qualifiedExpressionIsACollection(expression)) {
       subscriptionContext.addIssue(expression, MESSAGE);
     }
   }
@@ -68,13 +69,18 @@ private static void checkNestedTypes(SubscriptionContext subscriptionContext, Su
     expressions.forEach(nestedTypeExpression -> checkForGenericTypeWithoutArgument(subscriptionContext, nestedTypeExpression));
   }
 
-  private static boolean typeSupportsGenericsOrIsACollection(Expression expression) {
+  private static boolean shouldReportMissingTypeArguments(Expression expression) {
     if (expression.is(Tree.Kind.NAME)) {
       NameImpl name = (NameImpl) expression;
-      if (name.symbol() instanceof ClassSymbolImpl maybeSymbol) {
-        return Optional.of(maybeSymbol)
-          .map(ClassSymbolImpl::supportsGenerics)
-          .orElse(false);
+      if (name.symbol() instanceof ClassSymbolImpl classSymbol) {
+        if (classSymbol.genericInfo() instanceof GenericInfo.Generic(var bareTypeArguments)) {
+          // Preserve the rule's existing reporting policy when default information is unavailable.
+          return switch (bareTypeArguments) {
+            case NO_ANY -> false;
+            case CONTAINS_ANY, UNKNOWN -> true;
+          };
+        }
+        return false;
       } else {
         return isACollection(name.symbol());
       }

python-checks/src/test/java/org/sonar/python/checks/GenericTypeWithoutArgumentCheckTest.java

@@ -17,8 +17,26 @@
 package org.sonar.python.checks;
 
 import java.util.List;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.sonar.plugins.python.api.tree.BaseTreeVisitor;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.types.v2.GenericInfo.BareTypeArgumentStatus;
+import org.sonar.plugins.python.api.types.v2.GenericInfo;
+import org.sonar.python.SubscriptionVisitor;
+import org.sonar.python.TestPythonVisitorRunner;
+import org.sonar.python.caching.CacheContextImpl;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.index.GenericInfoProtobuf;
+import org.sonar.python.semantic.ClassSymbolImpl;
+import org.sonar.python.semantic.ProjectLevelSymbolTable;
+import org.sonar.python.tree.NameImpl;
+import org.sonar.python.types.protobuf.SymbolsProtos;
+
+import static org.assertj.core.api.Assertions.assertThat;
 
 class GenericTypeWithoutArgumentCheckTest {
 
@@ -27,6 +45,48 @@ void test() {
     PythonCheckVerifier.verify("src/test/resources/checks/genericTypeWithoutArgument.py", new GenericTypeWithoutArgumentCheck());
   }
 
+  @ParameterizedTest
+  @MethodSource("genericStates")
+  void generic_defaults_in_annotations(GenericInfo genericInfo, int expectedIssues) {
+    var file = new TestPythonVisitorRunner.MockPythonFile("", "defaults.py", """
+      value: Generic
+      nested: list[Generic]
+      def fn(arg: Generic) -> Generic:
+          ...
+      """);
+    var context = TestPythonVisitorRunner.createContext(file, null, "", ProjectLevelSymbolTable.empty(), CacheContextImpl.dummyCache());
+    var descriptor = SymbolsProtos.ClassSymbol.newBuilder().setName("Generic").setFullyQualifiedName("defaults.Generic")
+      .setIsGeneric(true).setGenericInfo(GenericInfoProtobuf.toProtobuf(genericInfo)).build();
+    var symbol = new ClassSymbolImpl(descriptor, "defaults");
+    // Inject a serialized class independently of the bundled Typeshed revision.
+    context.rootTree().accept(new BaseTreeVisitor() {
+      @Override
+      public void visitName(Name name) {
+        if ("Generic".equals(name.name())) {
+          ((NameImpl) name).setSymbol(symbol);
+        }
+      }
+    });
+    SubscriptionVisitor.analyze(List.of(new GenericTypeWithoutArgumentCheck()), context);
+    assertThat(context.getIssues()).hasSize(expectedIssues);
+  }
+
+  static Stream<Arguments> genericStates() {
+    return Stream.of(
+      Arguments.of(GenericInfo.UNKNOWN, 0),
+      Arguments.of(GenericInfo.NON_GENERIC, 0),
+      Arguments.of(new GenericInfo.Generic(BareTypeArgumentStatus.UNKNOWN), 4),
+      Arguments.of(new GenericInfo.Generic(BareTypeArgumentStatus.CONTAINS_ANY), 4),
+      Arguments.of(new GenericInfo.Generic(BareTypeArgumentStatus.NO_ANY), 0));
+  }
+
+  @Test
+  void concrete_defaults_survive_project_reexports() {
+    PythonCheckVerifier.verify(List.of(
+      "src/test/resources/checks/genericDefaultsExported.py",
+      "src/test/resources/checks/genericDefaultsImporting.py"), new GenericTypeWithoutArgumentCheck());
+  }
+
   @Test
   void test_cross_file() {
     PythonCheckVerifier.verify(

python-checks/src/test/resources/checks/genericDefaultsExported.py

@@ -0,0 +1,7 @@
+from anyio.abc import TaskStatus
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+class Required(Generic[T]):
+    pass

python-checks/src/test/resources/checks/genericDefaultsImporting.py

@@ -0,0 +1,12 @@
+from anyio.abc import TaskStatus as DirectStatus
+from genericDefaultsExported import TaskStatus as ReexportedStatus, Required
+
+direct: DirectStatus
+reexported: ReexportedStatus
+nested: list[ReexportedStatus]
+
+def status(arg: ReexportedStatus) -> ReexportedStatus:
+    ...
+
+required: Required  # Noncompliant
+explicit: Required[int]

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

@@ -44,7 +44,7 @@ public final class ClassType implements PythonType {
   private final List<PythonType> metaClasses;
   private final boolean hasDecorators;
   private final List<DecoratorInfo> decorators;
-  private final boolean isGeneric;
+  private final GenericInfo genericInfo;
   private final LocationInFile locationInFile;
 
   public ClassType(
@@ -71,6 +71,22 @@ public ClassType(
     boolean isGeneric,
     @Nullable LocationInFile locationInFile,
     List<DecoratorInfo> decorators) {
+    this(name, fullyQualifiedName, members, attributes, superClasses, metaClasses, hasDecorators,
+      GenericInfo.fromLegacy(isGeneric), locationInFile, decorators);
+  }
+
+  public ClassType(
+    String name,
+    String fullyQualifiedName,
+    Set<Member> members,
+    List<PythonType> attributes,
+    List<TypeWrapper> superClasses,
+    List<PythonType> metaClasses,
+    boolean hasDecorators,
+    GenericInfo genericInfo,
+    @Nullable LocationInFile locationInFile,
+    List<DecoratorInfo> decorators) {
+    this.genericInfo = genericInfo;
     this.decorators = List.copyOf(decorators);
     this.name = name;
     this.fullyQualifiedName = fullyQualifiedName;
@@ -79,7 +95,6 @@ public ClassType(
     this.superClasses = superClasses;
     this.metaClasses = metaClasses;
     this.hasDecorators = hasDecorators || !decorators.isEmpty();
-    this.isGeneric = isGeneric;
     this.locationInFile = locationInFile;
   }
 
@@ -364,7 +379,11 @@ public boolean hasDecorators() {
     return hasDecorators;
   }
 
+  public GenericInfo genericInfo() {
+    return genericInfo;
+  }
+
   public boolean isGeneric() {
-    return isGeneric;
+    return genericInfo.isGeneric();
   }
 }

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

@@ -0,0 +1,58 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * 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.plugins.python.api.types.v2;
+
+import org.sonar.api.Beta;
+
+/**
+ * Declaration-level generic information, independent of supplied type arguments.
+ * Unknown genericity is distinct from a known generic whose omitted arguments are unknown.
+ */
+@Beta
+public sealed interface GenericInfo {
+  GenericInfo UNKNOWN = new Unknown();
+  GenericInfo NON_GENERIC = new NonGeneric();
+
+  /** Compatibility query: false does not establish that a class is non-generic. */
+  default boolean isGeneric() {
+    return this instanceof Generic;
+  }
+
+  /** Legacy flags establish genericity only when true; they carry no default information. */
+  static GenericInfo fromLegacy(boolean isGeneric) {
+    return isGeneric ? new Generic(BareTypeArgumentStatus.UNKNOWN) : UNKNOWN;
+  }
+
+  record Unknown() implements GenericInfo {
+  }
+
+  record NonGeneric() implements GenericInfo {
+  }
+
+  /** Information about effective type arguments when no explicit arguments are supplied. */
+  record Generic(BareTypeArgumentStatus bareTypeArguments) implements GenericInfo {
+  }
+
+  enum BareTypeArgumentStatus {
+    /** Unsupported constructs, unresolved dependencies, or unavailable metadata. */
+    UNKNOWN,
+    /** At least one effective argument contains Any, including an omitted required parameter. */
+    CONTAINS_ANY,
+    /** Every effective argument has been established to be free of Any. */
+    NO_ANY
+  }
+}

python-frontend/src/main/java/org/sonar/python/index/ClassDescriptor.java

@@ -25,6 +25,7 @@
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import org.sonar.plugins.python.api.LocationInFile;
+import org.sonar.plugins.python.api.types.v2.GenericInfo;
 
 public class ClassDescriptor implements Descriptor {
 
@@ -40,12 +41,13 @@ public class ClassDescriptor implements Descriptor {
   private final boolean hasMetaClass;
   private final String metaclassFQN;
   private final List<Descriptor> metaClasses;
-  private final boolean supportsGenerics;
+  private final GenericInfo genericInfo;
   private final boolean isSelf;
 
   private ClassDescriptor(String name, String fullyQualifiedName, Collection<String> superClasses, Set<Descriptor> members,
     List<Descriptor> attributes, boolean hasDecorators, @Nullable LocationInFile definitionLocation, boolean hasSuperClassWithoutDescriptor,
-    boolean hasMetaClass, @Nullable String metaclassFQN, List<Descriptor> metaClasses, boolean supportsGenerics, boolean isSelf, List<DecoratorDescriptor> decorators) {
+    boolean hasMetaClass, @Nullable String metaclassFQN, List<Descriptor> metaClasses, GenericInfo genericInfo, boolean isSelf,
+    List<DecoratorDescriptor> decorators) {
 
     this.name = name;
     this.fullyQualifiedName = fullyQualifiedName;
@@ -59,7 +61,7 @@ private ClassDescriptor(String name, String fullyQualifiedName, Collection<Strin
     this.hasMetaClass = hasMetaClass;
     this.metaclassFQN = metaclassFQN;
     this.metaClasses = metaClasses;
-    this.supportsGenerics = supportsGenerics;
+    this.genericInfo = genericInfo;
     this.isSelf = isSelf;
   }
 
@@ -123,7 +125,11 @@ public List<Descriptor> metaClasses() {
   }
 
   public boolean supportsGenerics() {
-    return supportsGenerics;
+    return genericInfo.isGeneric();
+  }
+
+  public GenericInfo genericInfo() {
+    return genericInfo;
   }
 
   public boolean isSelf() {
@@ -144,7 +150,7 @@ public static class ClassDescriptorBuilder {
     private boolean hasMetaClass = false;
     private String metaclassFQN = null;
     private List<Descriptor> metaClasses = new ArrayList<>();
-    private boolean supportsGenerics = false;
+    private GenericInfo genericInfo = GenericInfo.UNKNOWN;
     private boolean isSelf = false;
 
     public ClassDescriptorBuilder withName(String name) {
@@ -207,8 +213,8 @@ public ClassDescriptorBuilder withMetaClasses(List<Descriptor> metaClasses) {
       return this;
     }
 
-    public ClassDescriptorBuilder withSupportsGenerics(boolean supportsGenerics) {
-      this.supportsGenerics = supportsGenerics;
+    public ClassDescriptorBuilder withGenericInfo(GenericInfo genericInfo) {
+      this.genericInfo = genericInfo;
       return this;
     }
 
@@ -219,7 +225,7 @@ public ClassDescriptorBuilder withIsSelf(boolean isSelf) {
 
     public ClassDescriptor build() {
       return new ClassDescriptor(name, fullyQualifiedName, superClasses, members, attributes, hasDecorators, definitionLocation,
-        hasSuperClassWithoutDescriptor, hasMetaClass, metaclassFQN, metaClasses, supportsGenerics, isSelf, decorators);
+        hasSuperClassWithoutDescriptor, hasMetaClass, metaclassFQN, metaClasses, genericInfo, isSelf, decorators);
     }
   }
 }

python-frontend/src/main/java/org/sonar/python/index/DescriptorUtils.java

@@ -22,8 +22,8 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
-import javax.annotation.Nullable;
 import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
 import org.sonar.plugins.python.api.symbols.Symbol;
 import org.sonar.plugins.python.api.types.InferredType;
 import org.sonar.python.index.TypeAnnotationDescriptor.TypeKind;
@@ -118,7 +118,7 @@ private static ClassDescriptor recreateClassDescriptor(AliasDescriptor aliasDesc
       .withMetaclassFQN(originalDescriptor.metaclassFQN())
       .withHasDecorators(originalDescriptor.hasDecorators())
       .withDecorators(originalDescriptor.decorators())
-      .withSupportsGenerics(originalDescriptor.supportsGenerics())
+      .withGenericInfo(originalDescriptor.genericInfo())
       .build();
   }
 

python-frontend/src/main/java/org/sonar/python/index/DescriptorsToProtobuf.java

@@ -87,7 +87,8 @@ private static DescriptorsProtos.ClassDescriptor toProtobuf(ClassDescriptor clas
       .setHasSuperClassWithoutDescriptor(classDescriptor.hasSuperClassWithoutDescriptor())
       .setHasMetaClass(classDescriptor.hasMetaClass())
       .setMetaClasses(toProtobufDescriptorList(classDescriptor.metaClasses()))
-      .setSupportsGenerics(classDescriptor.supportsGenerics());
+      .setSupportsGenerics(classDescriptor.supportsGenerics())
+      .setGenericInfo(GenericInfoProtobuf.toProtobuf(classDescriptor.genericInfo()));
     LocationInFile definitionLocation = classDescriptor.definitionLocation();
     if (definitionLocation != null) {
       builder.setDefinitionLocation(toProtobuf(definitionLocation));
@@ -246,7 +247,7 @@ private static ClassDescriptor fromProtobuf(DescriptorsProtos.ClassDescriptor cl
       .withHasMetaClass(classDescriptorProto.getHasMetaClass())
       .withMetaclassFQN(metaclassFQN)
       .withMetaClasses(metaClasses)
-      .withSupportsGenerics(classDescriptorProto.getSupportsGenerics())
+      .withGenericInfo(GenericInfoProtobuf.fromProtobuf(classDescriptorProto))
       .build();
   }