SONARPY-2332 Fix FP on S5845 when comparing enum objects with types

Author: thomas-serre-sonarsource

python-checks/src/test/resources/checks/tests/assertOnDissimilarTypes.py

@@ -198,8 +198,8 @@ class ComparingTypeAndEnum(unittest.TestCase):
     def test_type_of_enum_and_enum_class(self):
         EnumType = Enum("EnumType", names=["one", "two"])
         enum_member = EnumType(1)
-        # FP SONARPY-2332: EnumType is a proper "type" object since the Enum constructor with argument creates a new Enum type
-        self.assertIs(type(enum_member), EnumType) # Noncompliant
+        # EnumType is a proper "type" object since the Enum constructor with argument creates a new Enum type
+        self.assertIs(type(enum_member), EnumType)
 
 class DerivedEnumWithMembers(Enum):
     ONE = 1
@@ -208,7 +208,7 @@ class DerivedEnumWithMembers(Enum):
 class ComparingTypeAndDerivedEnumWithMembers(unittest.TestCase):
     def test_type_of_derived_enum_and_derived_enum_class(self):
         derived_enum_member = DerivedEnumWithMembers(1)
-        self.assertIs(type(enum_member), EnumType)
+        self.assertIs(type(derived_enum_member), EnumType)
 
 class DerivedEnumWithoutMembers(Enum):
     ...
@@ -218,12 +218,12 @@ class ComparingTypeAndDerivedEnumWithoutMembers(unittest.TestCase):
     def test_type_of_derived_enum_and_derived_enum_class(self):
         DerivedEnumType = DerivedEnumWithoutMembers("DerivedEnumType", names=["one", "two"])
         derived_enum_member = DerivedEnumType(1)
-        # FP SONARPY-2332: DerivedEnumType is a proper "type" object because `DerivedEnumWithoutMembers(str, list)` will create a new enum,
+        # DerivedEnumType is a proper "type" object because `DerivedEnumWithoutMembers(str, list)` will create a new enum,
         # just like `Enum(str, list)` would
-        self.assertIs(type(derived_enum_member), DerivedEnumType) # Noncompliant
+        self.assertIs(type(derived_enum_member), DerivedEnumType)
 
         DerivedEnumTypeFromDict = DerivedEnumWithoutMembers("DerivedEnumType", OrderedDict([("one", 1), ("two", 2)]))
         derived_enum_member_from_dict = DerivedEnumTypeFromDict(1)
-        # FP SONARPY-2332: DerivedEnumTypeFromDict is a proper "type" object because `DerivedEnumWithoutMembers(str, list)` will create a new enum,
+        # DerivedEnumTypeFromDict is a proper "type" object because `DerivedEnumWithoutMembers(str, list)` will create a new enum,
         # just like `Enum(str, list)`
-        self.assertIs(type(derived_enum_member_from_dict), DerivedEnumTypeFromDict) # Noncompliant
+        self.assertIs(type(derived_enum_member_from_dict), DerivedEnumTypeFromDict)

python-frontend/src/main/java/org/sonar/python/types/RuntimeType.java

@@ -31,6 +31,9 @@
 
 public class RuntimeType implements InferredType {
 
+  // Name of the type returned by the type() function
+  private static final String TYPE_CLASS_NAME = "type";
+
   private ClassSymbol typeClass;
   private String builtinFullyQualifiedName;
   private Set<String> typeClassSuperClassesFQN = null;
@@ -52,9 +55,27 @@ public boolean isIdentityComparableWith(InferredType other) {
     if (other instanceof UnionType) {
       return other.isIdentityComparableWith(this);
     }
+    if (isComparingTypeWithMetaclass(other)) {
+      return true;
+    }
     return this.equals(other);
   }
 
+  private boolean isComparingTypeWithMetaclass(InferredType other) {
+    if (other instanceof RuntimeType otherRuntimeType) {
+      boolean hasOtherMetaClass = hasMetaclassInHierarchy(otherRuntimeType);
+      boolean hasThisMetaClass = hasMetaclassInHierarchy(this);
+      return (TYPE_CLASS_NAME.equals(getTypeClass().name()) && hasOtherMetaClass)
+        || (hasThisMetaClass && TYPE_CLASS_NAME.equals(otherRuntimeType.getTypeClass().name()));
+    }
+    return false;
+  }
+
+  private static boolean hasMetaclassInHierarchy(RuntimeType runtimeType) {
+    return runtimeType.getTypeClass().hasMetaClass()
+      || runtimeType.getTypeClass().superClasses().stream().filter(ClassSymbol.class::isInstance).anyMatch(c -> ((ClassSymbol) c).hasMetaClass());
+  }
+
   @Override
   public boolean canHaveMember(String memberName) {
     if (MOCK_FQNS.stream().anyMatch(this::mustBeOrExtend)){

python-frontend/src/test/java/org/sonar/python/types/RuntimeTypeTest.java

@@ -64,6 +64,34 @@ void isIdentityComparableWith() {
     assertThat(aType.isIdentityComparableWith(new DeclaredType(b))).isTrue();
   }
 
+  @Test
+  void isIdentityComparableWithMetaclass() {
+    RuntimeType typeType = new RuntimeType(new ClassSymbolImpl("type", "type"));
+
+    ClassSymbolImpl metaclassSymbol = new ClassSymbolImpl("Meta", "Meta");
+    metaclassSymbol.setHasMetaClass();
+    RuntimeType metaClassType = new RuntimeType(metaclassSymbol);
+
+    ClassSymbolImpl classSymbolWithSuperMetaClass = new ClassSymbolImpl("SuperMeta", "SuperMeta");
+    classSymbolWithSuperMetaClass.addSuperClass(metaclassSymbol);
+    RuntimeType superMetaClassType = new RuntimeType(classSymbolWithSuperMetaClass);
+
+    UnknownClassType unknownClassType = new UnknownClassType(metaclassSymbol);
+
+    assertThat(typeType.isIdentityComparableWith(typeType)).isTrue();
+    assertThat(typeType.isIdentityComparableWith(metaClassType)).isTrue();
+    assertThat(typeType.isIdentityComparableWith(superMetaClassType)).isTrue();
+    assertThat(typeType.isIdentityComparableWith(unknownClassType)).isFalse();
+
+    assertThat(metaClassType.isIdentityComparableWith(typeType)).isTrue();
+    assertThat(metaClassType.isIdentityComparableWith(metaClassType)).isTrue();
+    assertThat(metaClassType.isIdentityComparableWith(superMetaClassType)).isFalse();
+
+    assertThat(superMetaClassType.isIdentityComparableWith(typeType)).isTrue();
+    assertThat(superMetaClassType.isIdentityComparableWith(metaClassType)).isFalse();
+    assertThat(superMetaClassType.isIdentityComparableWith(superMetaClassType)).isTrue();
+  }
+
   @Test
   void member() {
     ClassSymbolImpl x = new ClassSymbolImpl("x", "x");