SONARPY-1747 Fix incorrect type equality when classes vary in metaclass status (#1762)

Author: guillaume-dequenne

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

@@ -157,3 +157,28 @@ def test_other(self):
     self.assertEqual(5, *a)
     self.assertEqual("5", b)  # Noncompliant
     a.assertEqual("string", True)
+
+
+class AmbiguousSymbolsNoType(unittest.TestCase):
+    def test_signature_on_class(self):
+        class ClassWithMultipleDefinitions:
+            def __init__(self, a):
+                pass
+
+        class CM(type):
+            def __call__(cls, a):
+                pass
+        class ClassWithMultipleDefinitions(metaclass=CM):
+            def __init__(self, b):
+                pass
+
+        with ...:
+            class CM(type):
+                @classmethod
+                def __call__(cls, a):
+                    return a
+            class ClassWithMultipleDefinitions(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(ClassWithMultipleDefinitions(1), 1)  # OK, ambiguous type

python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/ClassSymbol.java

@@ -53,4 +53,7 @@ public interface ClassSymbol extends Symbol {
 
   @Beta
   boolean hasDecorators();
+
+  @Beta
+  boolean hasMetaClass();
 }

python-frontend/src/main/java/org/sonar/python/semantic/ClassSymbolImpl.java

@@ -254,6 +254,7 @@ public Optional<Symbol> resolveMember(String memberName) {
     return Optional.empty();
   }
 
+  @Override
   public boolean hasMetaClass() {
     return hasMetaClass || membersByName().get("__metaclass__") != null;
   }

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

@@ -474,9 +474,10 @@ public static boolean containsDeclaredType(InferredType type) {
   }
 
   public static String getBuiltinCategory(InferredType inferredType) {
-    return BUILTINS_TYPE_CATEGORY.keySet().stream()
+    List<String> list = BUILTINS_TYPE_CATEGORY.keySet().stream()
       .filter(inferredType::canOnlyBe)
-      .map(BUILTINS_TYPE_CATEGORY::get).findFirst().orElse(null);
+      .map(BUILTINS_TYPE_CATEGORY::get).toList();
+    return list.size() == 1 ? list.get(0) : null;
   }
 
   public static Map<String, String> getBuiltinsTypeCategory() {

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

@@ -112,6 +112,9 @@ public boolean equals(Object o) {
     RuntimeType that = (RuntimeType) o;
     return Objects.equals(getTypeClass().name(), that.getTypeClass().name()) &&
       Objects.equals(getTypeClass().fullyQualifiedName(), that.getTypeClass().fullyQualifiedName())
+      && Objects.equals(getTypeClass().hasUnresolvedTypeHierarchy(), that.getTypeClass().hasUnresolvedTypeHierarchy())
+      && Objects.equals(getTypeClass().hasDecorators(), that.getTypeClass().hasDecorators())
+      && Objects.equals(getTypeClass().hasMetaClass(), that.getTypeClass().hasMetaClass())
       && Objects.equals(typeClassSuperClassesFQN(), that.typeClassSuperClassesFQN())
       && Objects.equals(typeClassMembersFQN(), that.typeClassMembersFQN());
   }
@@ -136,7 +139,14 @@ boolean hasUnresolvedHierarchy() {
 
   @Override
   public int hashCode() {
-    return Objects.hash(getTypeClass().name(), getTypeClass().fullyQualifiedName(), typeClassSuperClassesFQN(), typeClassMembersFQN());
+    return Objects.hash(
+      getTypeClass().name(),
+      getTypeClass().fullyQualifiedName(),
+      getTypeClass().hasDecorators(),
+      getTypeClass().hasUnresolvedTypeHierarchy(),
+      getTypeClass().hasMetaClass(),
+      typeClassSuperClassesFQN(),
+      typeClassMembersFQN());
   }
 
   @Override

python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolTest.java

@@ -53,6 +53,7 @@ void no_parents() {
     ClassSymbol classSymbol = (ClassSymbol) symbol;
     assertThat(classSymbol.superClasses()).hasSize(0);
     assertThat(classSymbol.hasUnresolvedTypeHierarchy()).isFalse();
+    assertThat(classSymbol.hasMetaClass()).isFalse();
   }
 
   @Test

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

@@ -23,7 +23,6 @@
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
-
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.LocationInFile;
 import org.sonar.plugins.python.api.symbols.ClassSymbol;
@@ -35,14 +34,12 @@
 import org.sonar.python.PythonTestUtils;
 import org.sonar.python.semantic.AmbiguousSymbolImpl;
 import org.sonar.python.semantic.ClassSymbolImpl;
-import org.sonar.python.semantic.FunctionSymbolImpl;
 import org.sonar.python.semantic.SymbolImpl;
 import org.sonar.python.types.protobuf.SymbolsProtos;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.sonar.python.PythonTestUtils.lastExpression;
 import static org.sonar.python.PythonTestUtils.lastExpressionInFunction;
-import static org.sonar.python.PythonTestUtils.pythonFile;
 import static org.sonar.python.types.InferredTypes.COMPLEX;
 import static org.sonar.python.types.InferredTypes.DECL_INT;
 import static org.sonar.python.types.InferredTypes.DECL_STR;
@@ -501,6 +498,7 @@ void test_builtin_category() {
     assertThat(getBuiltinCategory(LIST)).isEqualTo(BuiltinTypes.LIST);
     assertThat(getBuiltinCategory(SET)).isEqualTo(BuiltinTypes.SET);
     assertThat(getBuiltinCategory(TUPLE)).isEqualTo(BuiltinTypes.TUPLE);
+    assertThat(getBuiltinCategory(anyType())).isNull();
     assertThat(getBuiltinsTypeCategory()).isNotNull();
     assertThat(getBuiltinsTypeCategory()).isNotEmpty();
   }

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

@@ -20,13 +20,15 @@
 package org.sonar.python.types;
 
 import java.util.Collections;
+import java.util.Set;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.symbols.ClassSymbol;
 import org.sonar.plugins.python.api.tree.ClassDef;
 import org.sonar.plugins.python.api.tree.FileInput;
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.plugins.python.api.types.InferredType;
 import org.sonar.python.PythonTestUtils;
+import org.sonar.python.index.ClassDescriptor;
 import org.sonar.python.semantic.ClassSymbolImpl;
 import org.sonar.python.semantic.SymbolImpl;
 import org.sonar.python.semantic.SymbolTableBuilder;
@@ -204,6 +206,18 @@ void test_equals() {
     RuntimeType x = new RuntimeType(new ClassSymbolImpl("X", null));
     RuntimeType y = new RuntimeType(new ClassSymbolImpl("Y", null));
     assertThat(x).isNotEqualTo(y);
+
+    RuntimeType fff1 = new RuntimeType(new ClassSymbolImpl(generateDescriptor(false, false, false), "a"));
+    RuntimeType fff2 = new RuntimeType(new ClassSymbolImpl(generateDescriptor(false, false, false), "a"));
+    RuntimeType tff = new RuntimeType(new ClassSymbolImpl(generateDescriptor(true, false, false), "a"));
+    RuntimeType ftf = new RuntimeType(new ClassSymbolImpl(generateDescriptor(false, true, false), "a"));
+    RuntimeType fft = new RuntimeType(new ClassSymbolImpl(generateDescriptor(false, false, true), "a"));
+
+    assertThat(fff1)
+      .isEqualTo(fff2)
+      .isNotEqualTo(tff)
+      .isNotEqualTo(ftf)
+      .isNotEqualTo(fft);
   }
 
   @Test
@@ -348,6 +362,19 @@ void test_mustBeOrExtend() {
     assertThat(typeX2.mustBeOrExtend("x2")).isTrue();
   }
 
+  ClassDescriptor generateDescriptor(boolean hasDecorators, boolean hasMetaClass, boolean hasUnresolvedHierarchy) {
+    return new ClassDescriptor("a",
+      "a",
+      Set.of(),
+      Set.of(),
+      hasDecorators,
+      null,
+      hasUnresolvedHierarchy,
+      hasMetaClass,
+      null,
+      false);
+  }
+
   @Test
   void test_resolveDeclaredMember() {
     ClassSymbolImpl typeClass = new ClassSymbolImpl("x", "x");