SONARPY-5066 Support sentinel union expressions

GitOrigin-RevId: 39b1eb0d8a83c949ea844d724e6f00f86cddf4e2

Author: joke1196

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

@@ -227,3 +227,13 @@ def ordinary_constants(value):
     value is subprocess.STDOUT  # Noncompliant
     member = subprocess.STDOUT
     value is member  # Noncompliant
+
+
+MISSING = sentinel("MISSING")
+
+
+def sentinel_identity_comparisons(value):
+    value is MISSING
+    MISSING is value
+    value is not MISSING
+    MISSING is not value

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

@@ -159,3 +159,13 @@ def locations_and_messages(param):
     param is mylist  # Noncompliant {{Replace this "is" operator with "==".}}
 #         ^^
 
+
+
+MISSING = sentinel("MISSING")
+
+
+def sentinel_identity_comparisons(value):
+    value is MISSING
+    MISSING is value
+    value is not MISSING
+    MISSING is not value

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

@@ -127,6 +127,9 @@ public class TrivialTypeInferenceVisitor extends BaseTreeVisitor {
   private static final TypeInferenceMatcher IS_NONE_OBJECT_TYPE = TypeInferenceMatcher.of(
     TypeInferenceMatchers.isObjectSatisfying(TypeInferenceMatchers.withFQN(BuiltinTypes.NONE_TYPE)));
 
+  private static final TypeInferenceMatcher IS_SENTINEL_OBJECT_TYPE = TypeInferenceMatcher.of(
+    TypeInferenceMatchers.isObjectOfType("sentinel"));
+
   private static final TypeInferenceMatcher IS_PRIMITIVE_TYPE = TypeInferenceMatcher.of(
     TypeInferenceMatchers.any(
       TypeInferenceMatchers.isObjectOfType("int"),
@@ -335,9 +338,9 @@ private boolean isTypeExpression(PythonType type) {
     if (type instanceof UnionType unionType) {
       return unionType.candidates().stream().allMatch(this::isTypeExpression);
     }
-    // None literals have type ObjectType[NoneType], not ClassType, so we need to handle them explicitly
-    // to support type expressions like `int | None`
-    return IS_NONE_OBJECT_TYPE.evaluate(type, typePredicateContext).isTrue();
+    // None literals and sentinels are ObjectTypes which are valid in type expressions.
+    return IS_NONE_OBJECT_TYPE.evaluate(type, typePredicateContext).isTrue()
+      || IS_SENTINEL_OBJECT_TYPE.evaluate(type, typePredicateContext).isTrue();
   }
 
   @Override

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

@@ -162,6 +162,21 @@ def __init__(self):
     assertThat(objectTypeExpression.typeV2()).isNotInstanceOf(UnknownType.class);
   }
 
+  @Test
+  void testCheckForBuiltinSentinelObjectType() {
+    var project = new TestProject();
+    Expression sentinelExpression = project.lastExpression("""
+      MISSING = sentinel("MISSING")
+      MISSING
+      """);
+
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+
+    assertThat(TypeMatchers.isObjectOfType("builtins.sentinel").evaluateFor(sentinelExpression, ctx)).isEqualTo(TriBool.TRUE);
+    assertThat(sentinelExpression.typeV2()).isNotInstanceOf(UnknownType.class);
+  }
+
   @Test
   void testCheckForFunctionType() {
     var project = new TestProject();

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

@@ -5224,6 +5224,46 @@ void nestedUnionTypeAlias() {
       );
   }
 
+  @Test
+  void sentinelTypeExpressions() {
+    FileInput root = inferTypes("""
+      MISSING = sentinel("MISSING")
+      left = MISSING | None
+      right = None | MISSING
+      nested = int | MISSING | None
+      """);
+
+    var statements = root.statements().statements();
+    var sentinelType = ((AssignmentStatement) statements.get(0)).assignedValue().typeV2();
+    assertThat(sentinelType).isInstanceOfSatisfying(ObjectType.class,
+      objectType -> assertThat(objectType.unwrappedType()).isInstanceOfSatisfying(ClassType.class,
+        classType -> assertThat(classType.fullyQualifiedName()).isEqualTo("sentinel")));
+
+    for (int statementIndex : List.of(1, 2)) {
+      var type = ((AssignmentStatement) statements.get(statementIndex)).assignedValue().typeV2();
+      assertThat(type).isInstanceOfSatisfying(UnionType.class,
+        union -> assertThat(union.candidates().stream().map(PythonType::unwrappedType).map(FullyQualifiedNameHelper::getFullyQualifiedName))
+          .containsExactlyInAnyOrder(Optional.of("sentinel"), Optional.of("NoneType")));
+    }
+
+    var nestedType = ((AssignmentStatement) statements.get(3)).assignedValue().typeV2();
+    assertThat(nestedType).isInstanceOfSatisfying(UnionType.class,
+      union -> assertThat(union.candidates().stream().map(PythonType::unwrappedType).map(FullyQualifiedNameHelper::getFullyQualifiedName))
+        .containsExactlyInAnyOrder(Optional.of("int"), Optional.of("sentinel"), Optional.of("NoneType")));
+  }
+
+  @Test
+  void userDefinedSentinelIsNotATypeExpression() {
+    FileInput root = inferTypes("""
+      class sentinel:
+        pass
+      result = sentinel() | None
+      """);
+
+    var assignment = (AssignmentStatement) root.statements().statements().get(1);
+    assertThat(assignment.assignedValue().typeV2()).isEqualTo(PythonType.UNKNOWN);
+  }
+
   @Test
   void bitwiseOrOnValuesDoesNotCreateUnionType() {
     FileInput root = inferTypes("""