Make sure ambiguous symbols are always flattened (#951)

Author: andrea-guarino-sonarsource

python-frontend/src/main/java/org/sonar/python/semantic/AmbiguousSymbolImpl.java

@@ -55,7 +55,20 @@ public static AmbiguousSymbol create(Set<Symbol> symbols) {
     if (!symbols.stream().map(Symbol::fullyQualifiedName).allMatch(fqn -> Objects.equals(firstSymbol.fullyQualifiedName(), fqn))) {
       return new AmbiguousSymbolImpl(resultingSymbolName, null, symbols);
     }
-    return new AmbiguousSymbolImpl(resultingSymbolName, firstSymbol.fullyQualifiedName(), symbols);
+    return new AmbiguousSymbolImpl(resultingSymbolName, firstSymbol.fullyQualifiedName(), flattenAmbiguousSymbols(symbols));
+  }
+
+  private static Set<Symbol> flattenAmbiguousSymbols(Set<Symbol> symbols) {
+    Set<Symbol> alternatives = new HashSet<>();
+    for (Symbol symbol : symbols) {
+      if (symbol.is(Kind.AMBIGUOUS)) {
+        Set<Symbol> flattenedAlternatives = flattenAmbiguousSymbols(((AmbiguousSymbol) symbol).alternatives());
+        alternatives.addAll(flattenedAlternatives);
+      } else {
+        alternatives.add(symbol);
+      }
+    }
+    return alternatives;
   }
 
   public static AmbiguousSymbol create(Symbol... symbols) {

python-frontend/src/test/java/org/sonar/python/semantic/AmbiguousSymbolTest.java

@@ -188,4 +188,17 @@ private Map<String, Symbol> symbols(String... code) {
     FileInput fileInput = parse(new SymbolTableBuilder("", PythonTestUtils.pythonFile("foo")), code);
     return fileInput.globalVariables().stream().collect(Collectors.toMap(Symbol::name, Function.identity()));
   }
+
+  @Test
+  public void nested_ambiguous_symbols_should_be_flattened() {
+    SymbolImpl foo1 = new SymbolImpl("foo", "mod.foo");
+    ClassSymbolImpl classSymbol1 = new ClassSymbolImpl("foo", "mod.foo");
+    AmbiguousSymbol ambiguousSymbol1 = AmbiguousSymbolImpl.create(foo1, classSymbol1);
+    SymbolImpl foo2 = new SymbolImpl("foo", "mod.foo");
+    ClassSymbolImpl classSymbol2 = new ClassSymbolImpl("foo", "mod.foo");
+    AmbiguousSymbol ambiguousSymbol2 = AmbiguousSymbolImpl.create(foo2, classSymbol2);
+    AmbiguousSymbol ambiguousSymbol = AmbiguousSymbolImpl.create(ambiguousSymbol1, ambiguousSymbol2);
+    assertThat(ambiguousSymbol.alternatives()).noneMatch(s -> s.is(Symbol.Kind.AMBIGUOUS));
+    assertThat(ambiguousSymbol.alternatives()).containsExactlyInAnyOrder(foo1, foo2, classSymbol1, classSymbol2);
+  }
 }

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

@@ -404,10 +404,9 @@ public void overloaded_functions() {
     assertThat(map.is(Kind.AMBIGUOUS)).isTrue();
     assertThat(((SymbolImpl) map).validForPythonVersions()).containsExactlyInAnyOrder("27", "35", "36", "37", "38", "39");
     ClassSymbol python3Symbol = (ClassSymbol) ((AmbiguousSymbol) map).alternatives().stream().filter(s -> s.is(Kind.CLASS)).findFirst().get();
-    AmbiguousSymbol python2Symbol = (AmbiguousSymbol) ((AmbiguousSymbol) map).alternatives().stream().filter(s -> s.is(Kind.AMBIGUOUS)).findFirst().get();
     assertThat(((ClassSymbolImpl) python3Symbol).validForPythonVersions()).containsExactlyInAnyOrder("35", "36", "37", "38", "39");
-    assertThat(((AmbiguousSymbolImpl) python2Symbol).validForPythonVersions()).containsExactly("27");
-    for (Symbol alternative : python2Symbol.alternatives()) {
+    Set<Symbol> python2Symbols = ((AmbiguousSymbol) map).alternatives().stream().filter(s -> s.is(Kind.FUNCTION)).collect(Collectors.toSet());
+    for (Symbol alternative : python2Symbols) {
       assertThat(alternative.is(Kind.FUNCTION)).isTrue();
       assertThat(((FunctionSymbolImpl) alternative).validForPythonVersions()).containsExactly("27");
     }