SONARPY-2332 implement ast based propagation of unary expressions

add stuff to trivial type propagation visistor

Author: Seppli11

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

@@ -95,7 +95,9 @@ private void applyPropagations(Set<Propagation> propagations, Set<SymbolV2> init
     }
   }
 
+
   private record Propagator(TypeTable typeTable) {
+
     /**
      * @return true if the propagation effectively changed the inferred type of assignment LHS
      */
@@ -125,6 +127,13 @@ private void propagateTypeToUsages(Propagation propagation, PythonType newType)
         // Avoid propagation to usages in nested scopes, as this may lead to FPs
         .filter(n -> isInSameScope(propagation, n, scopeTree))
         .forEach(n -> n.typeV2(newType));
+
+      updateTree(propagation);
+    }
+
+    private void updateTree(Propagation propagation) {
+      Tree scopeTree = propagation.scopeTree(propagation.lhsName());
+      scopeTree.accept(new TrivialTypePropagationVisitor(typeTable));
     }
 
     @CheckForNull

python-frontend/src/main/java/org/sonar/python/tree/UnaryExpressionImpl.java

@@ -27,10 +27,11 @@
 import org.sonar.plugins.python.api.tree.TreeVisitor;
 import org.sonar.plugins.python.api.tree.UnaryExpression;
 import org.sonar.plugins.python.api.types.InferredType;
+import org.sonar.python.types.HasTypeDependencies;
 import org.sonar.python.types.InferredTypes;
 import org.sonar.python.types.v2.PythonType;
 
-public class UnaryExpressionImpl extends PyTree implements UnaryExpression {
+public class UnaryExpressionImpl extends PyTree implements UnaryExpression, HasTypeDependencies {
 
   private static final Map<String, Kind> KINDS_BY_OPERATOR = kindsByOperator();
 
@@ -99,4 +100,9 @@ public UnaryExpression typeV2(PythonType type) {
   public PythonType typeV2() {
     return type;
   }
+
+  @Override
+  public List<Expression> typeDependencies() {
+    return List.of(expression);
+  }
 }

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

@@ -2610,6 +2610,18 @@ static Stream<Arguments> unary_expression_of_variables() {
       Arguments.of("x = True; ~x", INT_TYPE),
       Arguments.of("x = True; not x", BOOL_TYPE),
       Arguments.of("x = 1; not x", BOOL_TYPE),
+      Arguments.of("x = 1; y = -x; -y", INT_TYPE),
+      Arguments.of("x = 1; x = 1; y = -x; -y", INT_TYPE),
+      Arguments.of("x = 1; y = 1; y = -x; -y", INT_TYPE),
+
+      Arguments.of("""
+        if someCond:
+          x = 1
+        else:
+          x = True
+        y = x
+        -y
+        """, INT_TYPE),
 
       Arguments.of("x = 1; -(x + 1)", INT_TYPE)
     );
@@ -2618,10 +2630,20 @@ static Stream<Arguments> unary_expression_of_variables() {
   @ParameterizedTest
   @MethodSource("unary_expression_of_variables")
   void unary_expression_of_variables(String code, PythonType expectedType) {
-    assertThat(lastExpression(code)).extracting(expr -> expr.typeV2().unwrappedType()).isEqualTo(expectedType);
+    assertThat(lastExpression(code).typeV2()).isInstanceOf(ObjectType.class).extracting(PythonType::unwrappedType).isEqualTo(expectedType);
   }
 
 
+  @ParameterizedTest
+  @MethodSource("unary_expression_of_variables")
+  void unary_expression_of_variables_with_try_except(String code, PythonType expectedType) {
+    var codeWithTryCatch = """
+      try: pass
+      except: pass
+      """ + code;
+    assertThat(lastExpression(codeWithTryCatch)).extracting(expr -> expr.typeV2().unwrappedType()).isEqualTo(expectedType);
+  }
+
   @Test
   void imported_ambiguous_symbol() {
     FileInput fileInput = inferTypes("""