SONARPY-2921 Fix the stack overflow in case of inheritance loops for ClassType.resolveMember (#252)

GitOrigin-RevId: 1639651f5c931a8fb4ab21ab1432b15291cd534a

Author: maksim-grebeniuk-sonarsource

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

@@ -23,6 +23,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 import org.sonar.api.Beta;
@@ -127,8 +128,13 @@ public String key() {
 
   @Override
   public Optional<PythonType> resolveMember(String memberName) {
+    return resolveMember(memberName, new HashSet<>());
+  }
+
+  private Optional<PythonType> resolveMember(String memberName, Set<PythonType> visited) {
+    visited.add(this);
     return localMember(memberName)
-      .or(() -> inheritedMember(memberName));
+      .or(() -> inheritedMember(memberName, visited));
   }
 
   private Optional<PythonType> localMember(String memberName) {
@@ -138,9 +144,17 @@ private Optional<PythonType> localMember(String memberName) {
       .findFirst();
   }
 
-  private Optional<PythonType> inheritedMember(String memberName) {
+  private Optional<PythonType> inheritedMember(String memberName, Set<PythonType> visited) {
     return superClasses().stream()
-      .map(s -> s.type().resolveMember(memberName))
+      .map(TypeWrapper::type)
+      .filter(Predicate.not(visited::contains))
+      .map(t -> {
+        visited.add(t);
+        if (t instanceof ClassType superClassType) {
+          return superClassType.resolveMember(memberName, visited);
+        }
+        return t.resolveMember(memberName);
+      })
       .filter(Optional::isPresent)
       .map(Optional::get)
       .findFirst();

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

@@ -16,7 +16,9 @@
  */
 package org.sonar.plugins.python.api.types.v2;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.LocationInFile;
@@ -30,6 +32,7 @@
 import org.sonar.python.PythonTestUtils;
 import org.sonar.python.semantic.SymbolUtils;
 import org.sonar.python.semantic.v2.ClassTypeBuilder;
+import org.sonar.python.semantic.v2.ProjectLevelTypeTable;
 import org.sonar.python.semantic.v2.SymbolTableBuilderV2;
 import org.sonar.python.semantic.v2.SymbolV2;
 import org.sonar.python.semantic.v2.TypeInferenceV2;
@@ -38,6 +41,8 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.sonar.python.PythonTestUtils.parse;
 import static org.sonar.python.PythonTestUtils.parseWithoutSymbols;
+import static org.sonar.python.PythonTestUtils.pythonFile;
+import static org.sonar.python.semantic.ProjectLevelSymbolTable.empty;
 import static org.sonar.python.types.v2.TypesTestUtils.PROJECT_LEVEL_TYPE_TABLE;
 
 public class ClassTypeTest {
@@ -109,6 +114,45 @@ void multiple_local_parents() {
     assertThat(classB.superClasses()).extracting(TypeWrapper::type).containsExactlyInAnyOrder(classC, classA);
   }
 
+  @Test
+  void recursive_inheritance_resolve_member() {
+    var classTypes = multiFilesClassTypes(Map.ofEntries(
+        Map.entry(
+          "a.py",
+          """
+            from b import B
+            class A(B): ...
+            """
+        ),
+        Map.entry(
+          "b.py",
+          """
+            from a import A
+            class B(A): ...
+            """
+        )
+      )
+    );
+    ClassType classA = classTypes.get("a.A");
+    assertThat(classA.resolveMember("foo")).isEmpty();
+  }
+
+  @Test
+  void unresolved_inheritance_resolve_member() {
+    var classTypes = multiFilesClassTypes(Map.ofEntries(
+        Map.entry(
+          "a.py",
+          """
+            from b import B
+            class A(B): ...
+            """
+        )
+      )
+    );
+    ClassType classA = classTypes.get("a.A");
+    assertThat(classA.resolveMember("foo")).containsInstanceOf(UnknownType.UnresolvedImportType.class);
+  }
+
   @Test
   void unknown_parent() {
     List<ClassType> classTypes = classTypes(
@@ -611,4 +655,31 @@ public static List<ClassType> classTypes(String... code) {
       .map(ClassType.class::cast)
       .toList();
   }
+
+  public static Map<String, ClassType> multiFilesClassTypes(Map<String, String> filesCodes) {
+    var projectSymbolTable = empty();
+    var result = new HashMap<String, ClassType>();
+
+    filesCodes.forEach((fileName, code) -> {
+      var fileInput = parseWithoutSymbols(code);
+      projectSymbolTable.addModule(fileInput, "", pythonFile(fileName));
+    });
+
+    filesCodes.forEach((fileName, code) -> {
+      FileInput fileInput = parseWithoutSymbols(code);
+      var symbolTable = new SymbolTableBuilderV2(fileInput)
+        .build();
+
+      new TypeInferenceV2(new ProjectLevelTypeTable(projectSymbolTable), pythonFile(fileName), symbolTable, "").inferTypes(fileInput);
+      PythonTestUtils.getAllDescendant(fileInput, t -> t.is(Tree.Kind.CLASSDEF))
+        .stream()
+        .map(ClassDef.class::cast)
+        .map(ClassDef::name)
+        .map(Name::typeV2)
+        .map(ClassType.class::cast)
+        .forEach(ct -> result.put(ct.fullyQualifiedName(), ct));
+    });
+
+    return result;
+  }
 }