SONARPY-3699 Add CLI tool for agents (#806)

GitOrigin-RevId: 2136b155a91f9acf77c7ef0b3d9fbda7d5fee260

Author: Seppli11

override-dep-licenses.properties

@@ -3,4 +3,5 @@
 
 com.google.code.gson--gson--2.11.0=apache_v2
 commons-io--commons-io--2.17.0=apache_v2
-com.github.spotbugs=apache_v2
+com.github.spotbugs=apache_v2
+info.picocli--picocli--4.7.5=apache_v2

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

@@ -19,10 +19,12 @@
 import java.util.HashSet;
 import java.util.Optional;
 import java.util.Set;
+import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.CallExpression;
 import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.QualifiedExpression;
+import org.sonar.plugins.python.api.tree.RegularArgument;
 import org.sonar.plugins.python.api.types.v2.ClassType;
 import org.sonar.plugins.python.api.types.v2.FunctionType;
 import org.sonar.plugins.python.api.types.v2.ObjectType;
@@ -34,14 +36,21 @@
 import org.sonar.plugins.python.api.types.v2.UnknownType;
 import org.sonar.python.semantic.v2.types.TypeInferenceMatcher;
 import org.sonar.python.semantic.v2.types.TypeInferenceMatchers;
+import org.sonar.python.tree.TreeUtils;
 import org.sonar.python.types.v2.matchers.TypePredicateContext;
 
 public final class CallReturnTypeCalculator {
 
+  private static final String REVEAL_TYPE_FQN = "typing.reveal_type";
+
   private CallReturnTypeCalculator() {
   }
 
   public static PythonType computeCallExpressionType(CallExpression callExpr, TypePredicateContext typePredicateContext) {
+    if (isRevealTypeCall(callExpr, typePredicateContext)) {
+      return getFirstArgumentType(callExpr);
+    }
+
     PythonType calleeType = callExpr.callee().typeV2();
     TypeSource typeSource = computeTypeSource(calleeType, callExpr);
     PythonType returnType = returnTypeOfCall(calleeType);
@@ -179,5 +188,28 @@ private static TypeSource calleeTypeSource(CallExpression callExpr) {
     }
     return callExpr.callee().typeV2().typeSource();
   }
-}
 
+  private static boolean isRevealTypeCall(CallExpression callExpr, TypePredicateContext typePredicateContext) {
+    Expression callee = callExpr.callee();
+    if (!(callee instanceof Name name) || !"reveal_type".equals(name.name())) {
+      return false;
+    }
+
+    PythonType calleeType = callee.typeV2();
+
+    TriBool hasRevealTypeFqn = TypeInferenceMatcher.of(TypeInferenceMatchers.withFQN(REVEAL_TYPE_FQN))
+      .evaluate(calleeType, typePredicateContext);
+
+    boolean isLocallyDefined = calleeType != PythonType.UNKNOWN;
+
+    return hasRevealTypeFqn.isTrue() || !isLocallyDefined;
+  }
+
+  private static PythonType getFirstArgumentType(CallExpression callExpr) {
+    RegularArgument firstArg = TreeUtils.nthArgumentOrKeyword(0, "__obj", callExpr.arguments());
+    if (firstArg != null) {
+      return firstArg.expression().typeV2();
+    }
+    return PythonType.UNKNOWN;
+  }
+}

python-frontend/src/test/java/org/sonar/python/semantic/v2/types/typecalculator/CallReturnTypeCalculatorTest.java

@@ -480,4 +480,58 @@ def __call__(self) -> Self: ...
       .extracting(PythonType::unwrappedType)
       .isEqualTo(classDef.name().typeV2());
   }
+
+  @Test
+  void computeCallExpressionType_revealType_transparent() {
+    FileInput fileInput = parseAndInferTypes("""
+      x = 42
+      reveal_type(x)
+      """);
+
+    CallExpressionImpl callExpr = getLastDescendant(fileInput, CallExpression.class::isInstance);
+
+    PythonType result = CallReturnTypeCalculator.computeCallExpressionType(callExpr, typePredicateContext);
+    assertThat(result).isInstanceOf(ObjectType.class);
+    assertThat(((ObjectType) result).unwrappedType()).isEqualTo(TypesTestUtils.INT_TYPE);
+  }
+
+  @Test
+  void computeCallExpressionType_revealType_inTypeAnnotation() {
+    FileInput fileInput = parseAndInferTypes("""
+      def foo(x: reveal_type(int)): ...
+      """);
+
+    CallExpressionImpl callExpr = getFirstDescendant(fileInput, CallExpression.class::isInstance);
+
+    PythonType result = CallReturnTypeCalculator.computeCallExpressionType(callExpr, typePredicateContext);
+    assertThat(result).isEqualTo(TypesTestUtils.INT_TYPE);
+  }
+
+  @Test
+  void computeCallExpressionType_revealType_noArguments() {
+    FileInput fileInput = parseAndInferTypes("""
+      reveal_type()
+      """);
+
+    CallExpressionImpl callExpr = getLastDescendant(fileInput, CallExpression.class::isInstance);
+
+    PythonType result = CallReturnTypeCalculator.computeCallExpressionType(callExpr, typePredicateContext);
+    assertThat(result).isEqualTo(PythonType.UNKNOWN);
+  }
+
+  @Test
+  void computeCallExpressionType_revealType_locallyDefined_notTransparent() {
+    FileInput fileInput = parseAndInferTypes("""
+      def reveal_type(x) -> str:
+        return str(type(x))
+      x = 42
+      reveal_type(x)
+      """);
+
+    CallExpressionImpl callExpr = getLastDescendant(fileInput, CallExpression.class::isInstance);
+
+    PythonType result = CallReturnTypeCalculator.computeCallExpressionType(callExpr, typePredicateContext);
+    assertThat(result).isInstanceOf(ObjectType.class);
+    assertThat(((ObjectType) result).unwrappedType()).isEqualTo(TypesTestUtils.STR_TYPE);
+  }
 }