SONARPY-1609 Fix FP on S5886 when returning optional unions of unknow…

…n symbols (#1707)

python-checks/src/test/resources/checks/functionReturnType.py

@@ -334,3 +334,21 @@ def echo_round() -> Generator[int, float, str]:
 @contextlib.contextmanager
 def test() -> contextlib.AbstractContextManager[str]:
   yield "this is an example"
+
+
+def no_fp_on_optional_of_unknown_symbol(cond) -> Optional[Unknown]:
+    if cond == 42:
+        return 10  # OK
+    if cond == 24:
+        return "hello"  # OK
+    if cond == 5:
+        return None
+
+
+def no_fp_on_optional_union_of_unknown_symbol(cond) -> Optional[Union[str, Unknown]]:
+    if cond == 42:
+        return 10  # OK
+    if cond == 24:
+        return "hello"  # OK
+    if cond == 5:
+        return None

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

@@ -298,7 +298,9 @@ private static DeclaredType declaredTypeFromTypeAnnotationSubscription(Subscript
           .map(exp -> declaredTypeFromTypeAnnotation(exp, builtinSymbols))
           .collect(Collectors.toList());
         if (args.stream().anyMatch(Objects::isNull)) {
-          args = Collections.emptyList();
+          // null args indicate something was wrong in the resolution of some of the alternatives
+          // returning null here will ensure the resulting type will be AnyType, which will avoid potential FPs
+          return null;
         }
         String builtinFqn = ALIASED_ANNOTATIONS.get(symbol.fullyQualifiedName());
         return builtinFqn != null ? new DeclaredType(builtinSymbols.get(builtinFqn), args) : new DeclaredType(symbol, args);

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

@@ -301,9 +301,7 @@ void test_optional_type_annotations() {
     );
     assertThat(fromTypeshedTypeAnnotation(typeAnnotation)).isEqualTo(InferredTypes.anyType());
     declaredType = fromTypeAnnotation(typeAnnotation);
-    assertThat(declaredType).isInstanceOf(DeclaredType.class);
-    assertThat(((DeclaredType) declaredType).alternativeTypeSymbols()).extracting(Symbol::fullyQualifiedName)
-      .containsExactlyInAnyOrder("typing.Optional");
+    assertThat(declaredType).isInstanceOf(AnyType.class);
   }
 
   @Test