SONARPY-3535 Make typing.Any resolve to unknown (#692)

GitOrigin-RevId: 3654d801b7adbe525d24064a4cdfa063aea20d66

Author: Seppli11

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

@@ -20,13 +20,14 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
-import org.sonar.python.index.Descriptor;
-import org.sonar.python.semantic.ProjectLevelSymbolTable;
-import org.sonar.python.semantic.v2.converter.AnyDescriptorToPythonTypeConverter;
 import org.sonar.plugins.python.api.types.v2.ModuleType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.plugins.python.api.types.v2.TypeOrigin;
 import org.sonar.plugins.python.api.types.v2.TypeWrapper;
+import org.sonar.python.index.Descriptor;
+import org.sonar.python.semantic.ProjectLevelSymbolTable;
+import org.sonar.python.semantic.v2.converter.AnyDescriptorToPythonTypeConverter;
+import org.sonar.python.semantic.v2.dynamicstubs.DynamicStubsProvider;
 
 public class SymbolsModuleTypeProvider {
   private final ProjectLevelSymbolTable projectLevelSymbolTable;
@@ -94,6 +95,7 @@ private Optional<ModuleType> createModuleTypeFromTypeShed(String moduleName, Str
   }
 
   private ModuleType createModuleType(String moduleName, String moduleFqn, ModuleType parent, Map<String, TypeWrapper> members) {
+    members.putAll(DynamicStubsProvider.createDynamicStubs(moduleFqn));
     addTypingAliases(moduleFqn, members);
     return new ModuleType(moduleName, moduleFqn, parent, members);
   }

python-frontend/src/main/java/org/sonar/python/semantic/v2/dynamicstubs/DynamicStubsProvider.java

@@ -0,0 +1,48 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2025 SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.semantic.v2.dynamicstubs;
+
+import java.util.Map;
+import org.sonar.plugins.python.api.types.v2.PythonType;
+import org.sonar.plugins.python.api.types.v2.TypeWrapper;
+
+public class DynamicStubsProvider {
+
+  private DynamicStubsProvider() {
+  }
+
+  public static Map<String, TypeWrapper> createDynamicStubs(String moduleFqn) {
+    return switch (moduleFqn) {
+      case "typing" -> typingDynamicStubs();
+      default -> Map.of();
+    };
+  }
+
+  /**
+   * A lot of the types exported by the typing module need a special representation in the internal type system. 
+   * Furthermore, mypy isn't able to analyze moduels called "typing", as it clashes internally with the standard 
+   * library's typing module (see https://github.com/python/mypy/issues/1876). As a result, this function allows us 
+   * to create the proper special types for the typing module.
+   * 
+   * @return a map of the stubs for the typing module
+   */
+  private static Map<String, TypeWrapper> typingDynamicStubs() {
+    return Map.of(
+      // Every type is compatible with Any, and Any is compatible with every type. This is represented as UNKNOWN in PythonType
+      "Any", TypeWrapper.of(PythonType.UNKNOWN));
+  }
+}

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

@@ -4069,4 +4069,22 @@ def foo((a, b)):
     var fooMethodDef = (FunctionDef) classDef.body().statements().get(0);
     assertThat(fooMethodDef.name().typeV2()).isInstanceOf(FunctionType.class);
   }
+
+  @Test
+  void anyResolvesToUnknown() {
+    Expression anyExpression = lastExpression("""
+      from typing import Any
+      Any
+      """);
+    assertThat(anyExpression.typeV2()).isEqualTo(PythonType.UNKNOWN);
+  }
+
+  @Test
+  void typingExtensionsAnyResolvesToUnknown() {
+    Expression anyExpression = lastExpression("""
+      from typing_extensions import Any
+      Any
+      """);
+    assertThat(anyExpression.typeV2()).isEqualTo(PythonType.UNKNOWN);
+  }
 }