SONARPY-3505 Fix S5953 false positives on PEP 695 new generics syntax (#984)

sonar-nigel[bot] · Vibe Bot · sonartech · commit 57993cfa4d1d · 2026-03-30T13:32:38.000Z
Co-authored-by: Vibe Bot &lt;vibe-bot@sonarsource.com&gt;
GitOrigin-RevId: cf8686af965e1276e1ee6967c2fa5f0878a51a7a
diff --git a/python-checks/src/main/java/org/sonar/python/checks/UndefinedSymbolsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UndefinedSymbolsCheck.java
@@ -31,7 +31,9 @@
 import org.sonar.plugins.python.api.tree.ImportFrom;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.tree.TypeAliasStatement;
 import org.sonar.plugins.python.api.tree.TypeParams;
+import org.sonar.python.semantic.BuiltinSymbols;
 import org.sonar.python.tree.TreeUtils;
 
 @Rule(key = "S5953")
@@ -72,19 +74,22 @@ private static class UnresolvedSymbolsVisitor extends BaseTreeVisitor {
 
     @Override
     public void visitName(Name name) {
-      if (name.isVariable() && name.symbol() == null && !name.name().startsWith("_") && !isTypeVar(name)) {
+      if (name.isVariable() && name.symbolV2() == null && !BuiltinSymbols.all().contains(name.name()) && !name.name().startsWith("_") && !isTypeVar(name)) {
         nameIssues.computeIfAbsent(name.name(), k -> new ArrayList<>()).add(name);
       }
     }
 
     private static boolean isTypeVar(Name name) {
-      return TreeUtils.firstAncestor(name, tree -> classWithTypeVar(tree, name)) != null;
+      return TreeUtils.firstAncestor(name, tree -> hasTypeVarInScope(tree, name)) != null;
     }
 
-    private static boolean classWithTypeVar(Tree tree, Name name) {
+    private static boolean hasTypeVarInScope(Tree tree, Name name) {
       if (tree instanceof ClassDef classDef) {
         return hasTypeVar(classDef.typeParams(), name);
       }
+      if (tree instanceof TypeAliasStatement typeAliasStatement) {
+        return hasTypeVar(typeAliasStatement.typeParams(), name);
+      }
       return false;
     }
 
diff --git a/python-checks/src/test/resources/checks/genericTypeStatement.py b/python-checks/src/test/resources/checks/genericTypeStatement.py
@@ -20,13 +20,11 @@ def non_compliant_1():
     type MyAlias[T] = dict[T, _R]  # Noncompliant
     #    ^^^^^^^              ^^<    {{Use of "TypeVar" here.}}
 
-    M = TypeVar("M")
-    #   ^^^^^^^^^^^^>           {{"TypeVar" is assigned here.}}
-    type MyAlias[M] = set[M]  # Noncompliant
-    #    ^^^^^^^          ^<    {{Use of "TypeVar" here.}}
 
 
 def compliant(AType):
     type MyAlias[T] = dict[T, str]
     type MyAlias = set[str]
     type MyAlias = set[AType]
+    M = TypeVar("M")
+    type MyAlias[M] = set[M]  # Compliant: M in set[M] refers to the type parameter, not the TypeVar
diff --git a/python-checks/src/test/resources/checks/undefinedSymbols/undefinedSymbols.py b/python-checks/src/test/resources/checks/undefinedSymbols/undefinedSymbols.py
@@ -163,6 +163,30 @@ def from_class_def(self):
     def unknow_generic(self):
         a: list[X] = ... # Noncompliant
 
+class GenericClassBuiltinBound[ItemType, ItemTypeId: str]:
+    pass
+
+class BaseBound:
+    pass
+
+class GenericClassUserDefinedBound[FooT: BaseBound]:
+    pass
+
+class UserBase:
+    pass
+
+class UserGeneric[UBased: UserBase]:
+    def __init__(self, value: UBased) -> None:
+        self.value = value
+
+from collections.abc import Callable
+type Validator[V] = Callable[[V], V]
+
+class Serializable:
+    pass
+
+type SerializableList[S: Serializable] = list[S]
+
 # FP with python 2 syntax for exception handling
 try:
   ""
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/SymbolTableBuilder.java b/python-frontend/src/main/java/org/sonar/python/semantic/SymbolTableBuilder.java
@@ -342,6 +342,7 @@ private void createTypeParameters(@Nullable TypeParams typeParams) {
     @Override
     public void visitTypeAliasStatement(TypeAliasStatement typeAliasStatement) {
       addBindingUsage(typeAliasStatement.name(), Usage.Kind.TYPE_ALIAS_DECLARATION);
+      createTypeParameters(typeAliasStatement.typeParams());
       super.visitTypeAliasStatement(typeAliasStatement);
     }
 
@@ -697,6 +698,7 @@ public void visitTypeAnnotation(TypeAnnotation tree) {
     public void visitClassDef(ClassDef pyClassDefTree) {
       scan(pyClassDefTree.args());
       scan(pyClassDefTree.decorators());
+      scan(pyClassDefTree.typeParams());
       enterScope(pyClassDefTree);
       scan(pyClassDefTree.name());
       resolveTypeHierarchy(pyClassDefTree, pyClassDefTree.name().symbol(), pythonFile, scopesByRootTree.get(fileInput).symbolsByName);
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/ReadUsagesVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/ReadUsagesVisitor.java
@@ -121,6 +121,7 @@ public void visitTypeAnnotation(TypeAnnotation tree) {
   public void visitClassDef(ClassDef classDef) {
     scan(classDef.args());
     scan(classDef.decorators());
+    scan(classDef.typeParams());
     enterScope(classDef);
     scan(classDef.name());
     scan(classDef.body());
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/WriteUsagesVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/WriteUsagesVisitor.java
@@ -171,6 +171,7 @@ private void addTupleParamElementsToBindingUsage(TupleParameter param) {
   @Override
   public void visitTypeAliasStatement(TypeAliasStatement typeAliasStatement) {
     currentScope().addBindingUsage(typeAliasStatement.name(), UsageV2.Kind.TYPE_ALIAS_DECLARATION);
+    createTypeParameters(typeAliasStatement.typeParams());
     super.visitTypeAliasStatement(typeAliasStatement);
   }
 
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/SymbolTableBuilderTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/SymbolTableBuilderTest.java
@@ -35,6 +35,7 @@
 import org.sonar.plugins.python.api.symbols.Usage;
 import org.sonar.plugins.python.api.tree.BaseTreeVisitor;
 import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.ClassDef;
 import org.sonar.plugins.python.api.tree.ComprehensionExpression;
 import org.sonar.plugins.python.api.tree.DictCompExpression;
 import org.sonar.plugins.python.api.tree.ExpressionStatement;
@@ -44,6 +45,7 @@
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.plugins.python.api.tree.Tuple;
+import org.sonar.plugins.python.api.tree.TypeAliasStatement;
 import org.sonar.python.PythonTestUtils;
 import org.sonar.python.TestPythonVisitorRunner;
 import org.sonar.python.tree.TreeUtils;
@@ -636,6 +638,33 @@ void type_alias_declaration() {
     assertThat(symbolByName.get("M").usages().get(0).kind()).isEqualTo(Usage.Kind.TYPE_ALIAS_DECLARATION);
   }
 
+  @Test
+  void class_type_param_bound_resolved_in_enclosing_scope() {
+    FileInput tree = PythonTestUtils.parse(
+      "class BaseBound:",
+      "    pass",
+      "class Foo[T: BaseBound]:",
+      "    pass"
+    );
+    ClassDef fooClass = (ClassDef) PythonTestUtils.getLastDescendant(tree, t -> t.is(Tree.Kind.CLASSDEF));
+    Name boundName = (Name) fooClass.typeParams().typeParamsList().get(0).typeAnnotation().expression();
+    assertThat(boundName.name()).isEqualTo("BaseBound");
+    assertThat(boundName.symbol()).isNotNull();
+    assertThat(boundName.symbol().name()).isEqualTo("BaseBound");
+  }
+
+  @Test
+  void type_alias_type_params_registered() {
+    FileInput tree = PythonTestUtils.parse("type Alias[T] = list[T]");
+    TypeAliasStatement typeAlias = (TypeAliasStatement) tree.statements().statements().get(0);
+    Name typeParamName = typeAlias.typeParams().typeParamsList().get(0).name();
+    assertThat(typeParamName.name()).isEqualTo("T");
+    assertThat(typeParamName.symbol()).isNotNull();
+    assertThat(typeParamName.symbol().usages())
+      .extracting(Usage::kind)
+      .contains(Usage.Kind.TYPE_PARAM_DECLARATION);
+  }
+
   private static class TestVisitor extends BaseTreeVisitor {
     @Override
     public void visitFunctionDef(FunctionDef pyFunctionDefTree) {
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolTableBuilderV2Test.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolTableBuilderV2Test.java
@@ -22,12 +22,15 @@
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.symbols.v2.SymbolV2;
+import org.sonar.plugins.python.api.symbols.v2.UsageV2;
 import org.sonar.plugins.python.api.tree.AssignmentStatement;
+import org.sonar.plugins.python.api.tree.ClassDef;
 import org.sonar.plugins.python.api.tree.FileInput;
 import org.sonar.plugins.python.api.tree.FunctionDef;
 import org.sonar.plugins.python.api.tree.ImportName;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.tree.TypeAliasStatement;
 import org.sonar.python.PythonTestUtils;
 import org.sonar.python.tree.TreeUtils;
 
@@ -260,6 +263,33 @@ void never_written_variables_have_symbol() {
   }
 
 
+  @Test
+  void class_type_param_bound_is_resolved_in_enclosing_scope() {
+    FileInput fileInput = PythonTestUtils.parse("""
+        class BaseBound:
+            pass
+        class Foo[T: BaseBound]:
+            pass
+        """);
+    new SymbolTableBuilderV2(fileInput).build();
+    ClassDef fooClass = (ClassDef) fileInput.statements().statements().get(1);
+    Name boundName = (Name) fooClass.typeParams().typeParamsList().get(0).typeAnnotation().expression();
+    Assertions.assertThat(boundName.symbolV2()).isNotNull();
+    Assertions.assertThat(boundName.symbolV2().name()).isEqualTo("BaseBound");
+  }
+
+  @Test
+  void type_alias_type_params_are_registered() {
+    FileInput fileInput = PythonTestUtils.parse("type Alias[T] = list[T]");
+    new SymbolTableBuilderV2(fileInput).build();
+    TypeAliasStatement typeAlias = (TypeAliasStatement) fileInput.statements().statements().get(0);
+    Name typeParamName = typeAlias.typeParams().typeParamsList().get(0).name();
+    Assertions.assertThat(typeParamName.symbolV2()).isNotNull();
+    Assertions.assertThat(typeParamName.symbolV2().usages())
+      .extracting(UsageV2::kind)
+      .contains(UsageV2.Kind.TYPE_PARAM_DECLARATION);
+  }
+
   private static void assertNameSymbol(Name name, String expectedSymbolName, int expectedUsagesCount) {
     var symbol = name.symbolV2();
     Assertions.assertThat(symbol).isNotNull();

Original file line number	Diff line number	Diff line change
`@@ -171,6 +171,7 @@ private void addTupleParamElementsToBindingUsage(TupleParameter param) {`
`171`	`171`	`@Override`
`172`	`172`	`public void visitTypeAliasStatement(TypeAliasStatement typeAliasStatement) {`
`173`	`173`	`currentScope().addBindingUsage(typeAliasStatement.name(), UsageV2.Kind.TYPE_ALIAS_DECLARATION);`
	`174`	`+ createTypeParameters(typeAliasStatement.typeParams());`
`174`	`175`	`super.visitTypeAliasStatement(typeAliasStatement);`
`175`	`176`	`}`
`176`	`177`