Avoid copying symbols that come from the project table and fix bug for ambiguous descriptors with null FQN (#1040)

guillaume-dequenne · web-flow · commit 5f7804b5c897 · 2021-12-17T18:25:49.000+01:00
diff --git a/python-frontend/src/main/java/org/sonar/python/index/DescriptorUtils.java b/python-frontend/src/main/java/org/sonar/python/index/DescriptorUtils.java
@@ -20,6 +20,7 @@
 package org.sonar.python.index;
 
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -116,43 +117,52 @@ private static List<FunctionDescriptor.Parameter> parameters(List<FunctionSymbol
     )).collect(Collectors.toList());
   }
 
+  // TODO SONARPY-958: Cleanup the symbol construction from descriptors by extracting this logic in a builder class
   public static Symbol symbolFromDescriptor(Descriptor descriptor, ProjectLevelSymbolTable projectLevelSymbolTable,
-                                            @Nullable String localSymbolName, Map<String, Symbol> createdSymbols) {
-    // The symbol generated from the descriptor will not have the descriptor name if an alias (localSymbolName) is defined
-    if (createdSymbols.containsKey(descriptor.fullyQualifiedName())) {
-      return createdSymbols.get(descriptor.fullyQualifiedName());
+                                            @Nullable String localSymbolName, Map<Descriptor, Symbol> createdSymbolsByDescriptor, Map<String, Symbol> createdSymbolsByFqn) {
+    if (createdSymbolsByDescriptor.containsKey(descriptor)) {
+      return createdSymbolsByDescriptor.get(descriptor);
+    } else if (descriptor.fullyQualifiedName() != null && createdSymbolsByFqn.containsKey(descriptor.fullyQualifiedName())) {
+      return createdSymbolsByFqn.get(descriptor.fullyQualifiedName());
     }
+    // The symbol generated from the descriptor will not have the descriptor name if an alias (localSymbolName) is defined
     String symbolName = localSymbolName != null ? localSymbolName : descriptor.name();
     switch (descriptor.kind()) {
       case CLASS:
-        return createClassSymbol(descriptor, projectLevelSymbolTable, createdSymbols, symbolName);
+        return createClassSymbol(descriptor, projectLevelSymbolTable, createdSymbolsByDescriptor, createdSymbolsByFqn, symbolName);
       case FUNCTION:
-        return createFunctionSymbol((FunctionDescriptor) descriptor, projectLevelSymbolTable, createdSymbols, symbolName);
+        return createFunctionSymbol((FunctionDescriptor) descriptor, projectLevelSymbolTable, createdSymbolsByDescriptor, createdSymbolsByFqn, symbolName);
       case VARIABLE:
         return new SymbolImpl(symbolName, descriptor.fullyQualifiedName());
       case AMBIGUOUS:
-        Set<Symbol> alternatives = ((AmbiguousDescriptor) descriptor).alternatives().stream()
-          .map(a -> DescriptorUtils.symbolFromDescriptor(a, projectLevelSymbolTable, symbolName, createdSymbols))
-          .collect(Collectors.toSet());
-        return new AmbiguousSymbolImpl(symbolName, descriptor.fullyQualifiedName(), alternatives);
+        Set<Symbol> alternatives = new HashSet<>();
+        AmbiguousSymbolImpl ambiguousSymbol = new AmbiguousSymbolImpl(symbolName, descriptor.fullyQualifiedName(), alternatives);
+        createdSymbolsByDescriptor.put(descriptor, ambiguousSymbol);
+        alternatives.addAll(((AmbiguousDescriptor) descriptor).alternatives().stream()
+          .map(a -> DescriptorUtils.symbolFromDescriptor(a, projectLevelSymbolTable, symbolName, createdSymbolsByDescriptor, createdSymbolsByFqn))
+          .collect(Collectors.toSet()));
+        return ambiguousSymbol;
       default:
         throw new IllegalStateException(String.format("Error while creating a Symbol from a Descriptor: Unexpected descriptor kind: %s", descriptor.kind()));
     }
   }
 
-  private static ClassSymbolImpl createClassSymbol(Descriptor descriptor, ProjectLevelSymbolTable projectLevelSymbolTable, Map<String, Symbol> createdSymbols, String symbolName) {
+  private static ClassSymbolImpl createClassSymbol(Descriptor descriptor, ProjectLevelSymbolTable projectLevelSymbolTable, Map<Descriptor, Symbol> createdSymbolsByDescriptor,
+    Map<String, Symbol> createdSymbolByFqn, String symbolName) {
     ClassDescriptor classDescriptor = (ClassDescriptor) descriptor;
     ClassSymbolImpl classSymbol = new ClassSymbolImpl((ClassDescriptor) descriptor, symbolName);
-    createdSymbols.put(descriptor.fullyQualifiedName(), classSymbol);
-    addSuperClasses(classSymbol, classDescriptor, projectLevelSymbolTable, createdSymbols);
-    addMembers(classSymbol, classDescriptor, projectLevelSymbolTable, createdSymbols);
+    createdSymbolsByDescriptor.put(descriptor, classSymbol);
+    createdSymbolByFqn.put(descriptor.fullyQualifiedName(), classSymbol);
+    addSuperClasses(classSymbol, classDescriptor, projectLevelSymbolTable, createdSymbolsByDescriptor, createdSymbolByFqn);
+    addMembers(classSymbol, classDescriptor, projectLevelSymbolTable, createdSymbolsByDescriptor, createdSymbolByFqn);
     return classSymbol;
   }
 
   private static void addMembers(ClassSymbolImpl classSymbol, ClassDescriptor classDescriptor,
-                                 ProjectLevelSymbolTable projectLevelSymbolTable, Map<String, Symbol> createdSymbols) {
+                                 ProjectLevelSymbolTable projectLevelSymbolTable, Map<Descriptor, Symbol> createdSymbolsByDescriptor,
+    Map<String , Symbol> createdSymbolsByFqn) {
     classSymbol.addMembers(classDescriptor.members().stream()
-      .map(memberFqn -> DescriptorUtils.symbolFromDescriptor(memberFqn, projectLevelSymbolTable, null, createdSymbols))
+      .map(memberFqn -> DescriptorUtils.symbolFromDescriptor(memberFqn, projectLevelSymbolTable, null, createdSymbolsByDescriptor, createdSymbolsByFqn))
       .map(member -> {
         if (member instanceof FunctionSymbolImpl) {
           ((FunctionSymbolImpl) member).setOwner(classSymbol);
@@ -163,47 +173,49 @@ private static void addMembers(ClassSymbolImpl classSymbol, ClassDescriptor clas
   }
 
   private static void addSuperClasses(ClassSymbolImpl classSymbol, ClassDescriptor classDescriptor,
-                                      ProjectLevelSymbolTable projectLevelSymbolTable, Map<String, Symbol> createdSymbols) {
+                                      ProjectLevelSymbolTable projectLevelSymbolTable, Map<Descriptor, Symbol> createdSymbolsByDescriptor,
+    Map<String, Symbol> createdSymbolsByFqn) {
     classDescriptor.superClasses().stream()
       .map(superClassFqn -> {
-          if (createdSymbols.containsKey(superClassFqn)) {
-            return createdSymbols.get(superClassFqn);
+          if (createdSymbolsByFqn.containsKey(superClassFqn)) {
+            return createdSymbolsByFqn.get(superClassFqn);
           }
-          Symbol symbol = projectLevelSymbolTable.getSymbol(superClassFqn, null, createdSymbols);
+          Symbol symbol = projectLevelSymbolTable.getSymbol(superClassFqn, null, createdSymbolsByDescriptor, createdSymbolsByFqn);
           symbol = symbol != null ? symbol : typeshedSymbolWithFQN(superClassFqn);
-          createdSymbols.put(superClassFqn, symbol);
+          createdSymbolsByFqn.put(superClassFqn, symbol);
           return symbol;
         }
       )
       .forEach(classSymbol::addSuperClass);
   }
 
   private static FunctionSymbolImpl createFunctionSymbol(FunctionDescriptor functionDescriptor, ProjectLevelSymbolTable projectLevelSymbolTable,
-                                                         Map<String, Symbol> createdSymbols, String symbolName) {
+                                                         Map<Descriptor, Symbol> createdSymbolsByDescriptor, Map<String, Symbol> createdSymbolsByFqn,
+                                                         String symbolName) {
     FunctionSymbolImpl functionSymbol = new FunctionSymbolImpl(functionDescriptor, symbolName);
-    addParameters(functionSymbol, functionDescriptor, projectLevelSymbolTable, createdSymbols);
+    addParameters(functionSymbol, functionDescriptor, projectLevelSymbolTable, createdSymbolsByDescriptor, createdSymbolsByFqn);
     return functionSymbol;
   }
 
   private static void addParameters(FunctionSymbolImpl functionSymbol, FunctionDescriptor functionDescriptor,
-                                    ProjectLevelSymbolTable projectLevelSymbolTable, Map<String, Symbol> createdSymbols) {
+                                    ProjectLevelSymbolTable projectLevelSymbolTable, Map<Descriptor, Symbol> createdSymbolsByDescriptor, Map<String, Symbol> createdSymbolsByFqn) {
     functionDescriptor.parameters().stream().map(parameterDescriptor -> {
       FunctionSymbolImpl.ParameterImpl parameter = new FunctionSymbolImpl.ParameterImpl(parameterDescriptor);
-      setParameterType(parameter, parameterDescriptor.annotatedType(), projectLevelSymbolTable, createdSymbols);
+      setParameterType(parameter, parameterDescriptor.annotatedType(), projectLevelSymbolTable, createdSymbolsByDescriptor, createdSymbolsByFqn);
       return parameter;
     }).forEach(functionSymbol::addParameter);
   }
 
-  private static void setParameterType(FunctionSymbolImpl.ParameterImpl parameter, String annotatedType,
-                                       ProjectLevelSymbolTable projectLevelSymbolTable, Map<String, Symbol> createdSymbols) {
+  private static void setParameterType(FunctionSymbolImpl.ParameterImpl parameter, String annotatedType, ProjectLevelSymbolTable projectLevelSymbolTable,
+                                       Map<Descriptor, Symbol> createdSymbolsByDescriptor, Map<String, Symbol> createdSymbolsByFqn) {
     InferredType declaredType;
     if (parameter.isKeywordVariadic()) {
       declaredType = InferredTypes.DICT;
     } else if (parameter.isPositionalVariadic()) {
       declaredType = InferredTypes.TUPLE;
     } else {
-      Symbol existingSymbol = createdSymbols.get(annotatedType);
-      Symbol typeSymbol = existingSymbol != null ? existingSymbol : projectLevelSymbolTable.getSymbol(annotatedType, null, createdSymbols);
+      Symbol existingSymbol = createdSymbolsByFqn.get(annotatedType);
+      Symbol typeSymbol = existingSymbol != null ? existingSymbol : projectLevelSymbolTable.getSymbol(annotatedType, null, createdSymbolsByDescriptor, createdSymbolsByFqn);
       String annotatedTypeName = parameter.annotatedTypeName();
       if (typeSymbol == null && annotatedTypeName != null) {
         typeSymbol = typeshedSymbolWithFQN(annotatedTypeName);
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/ProjectLevelSymbolTable.java b/python-frontend/src/main/java/org/sonar/python/semantic/ProjectLevelSymbolTable.java
@@ -137,24 +137,26 @@ public Symbol getSymbol(@Nullable String fullyQualifiedName) {
   }
 
   public Symbol getSymbol(@Nullable String fullyQualifiedName, @Nullable String localSymbolName) {
-    return getSymbol(fullyQualifiedName, localSymbolName, new HashMap<>());
+    return getSymbol(fullyQualifiedName, localSymbolName, new HashMap<>(), new HashMap<>());
   }
 
-  public Symbol getSymbol(@Nullable String fullyQualifiedName, @Nullable String localSymbolName, Map<String, Symbol> createdSymbols) {
+  public Symbol getSymbol(@Nullable String fullyQualifiedName, @Nullable String localSymbolName,
+                          Map<Descriptor, Symbol> createdSymbolsByDescriptor, Map<String, Symbol> createdSymbolsByFqn) {
     if (fullyQualifiedName == null) return null;
     Descriptor descriptor = globalDescriptorsByFQN().get(fullyQualifiedName);
-    return descriptor == null ? null : DescriptorUtils.symbolFromDescriptor(descriptor, this, localSymbolName, createdSymbols);
+    return descriptor == null ? null : DescriptorUtils.symbolFromDescriptor(descriptor, this, localSymbolName, createdSymbolsByDescriptor, createdSymbolsByFqn);
   }
 
   @CheckForNull
   public Set<Symbol> getSymbolsFromModule(@Nullable String moduleName) {
     Set<Descriptor> descriptors = globalDescriptorsByModuleName.get(moduleName);
-    Map<String, Symbol> createdSymbols = new HashMap<>();
     if (descriptors == null) {
       return null;
     }
+    Map<Descriptor, Symbol> createdSymbolsByDescriptor = new HashMap<>();
+    Map<String, Symbol> createdSymbolsByFqn = new HashMap<>();
     return descriptors.stream()
-      .map(desc -> DescriptorUtils.symbolFromDescriptor(desc, this, null, createdSymbols)).collect(Collectors.toSet());
+      .map(desc -> DescriptorUtils.symbolFromDescriptor(desc, this, null, createdSymbolsByDescriptor, createdSymbolsByFqn)).collect(Collectors.toSet());
   }
 
   public boolean isDjangoView(@Nullable String fqn) {
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/Scope.java b/python-frontend/src/main/java/org/sonar/python/semantic/Scope.java
@@ -82,15 +82,14 @@ void createBuiltinSymbol(String name, Map<String, Symbol> typeShedSymbols) {
 
   void createSymbolsFromWildcardImport(Set<Symbol> importedSymbols, ImportFrom importFrom) {
     importedSymbols.forEach(symbol -> {
-      Symbol importedSymbol = copySymbol(symbol.name(), symbol);
-      if (!isExistingSymbol(importedSymbol.name())) {
-        symbols.add(importedSymbol);
-        symbolsByName.put(symbol.name(), importedSymbol);
-        ((SymbolImpl) importedSymbol).addUsage(importFrom, Usage.Kind.IMPORT);
+      if (!isExistingSymbol(symbol.name())) {
+        symbols.add(symbol);
+        symbolsByName.put(symbol.name(), symbol);
+        ((SymbolImpl) symbol).addUsage(importFrom, Usage.Kind.IMPORT);
       } else {
         SymbolImpl originalSymbol = resolve(symbol.name());
         if (originalSymbol != null) {
-          resetSymbolInfo(importedSymbol.fullyQualifiedName(), originalSymbol);
+          resetSymbolInfo(symbol.fullyQualifiedName(), originalSymbol);
           originalSymbol.addUsage(importFrom, Usage.Kind.IMPORT);
         }
       }
@@ -123,7 +122,7 @@ void addFunctionSymbol(FunctionDef functionDef, @Nullable String fullyQualifiedN
     }
   }
 
-  private Symbol copySymbol(String symbolName, Symbol symbol) {
+  public Symbol copySymbol(String symbolName, Symbol symbol) {
     return copySymbol(symbolName, symbol, new HashSet<>());
   }
 
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/SymbolTableBuilder.java b/python-frontend/src/main/java/org/sonar/python/semantic/SymbolTableBuilder.java
@@ -365,7 +365,8 @@ public void visitImportFrom(ImportFrom importFrom) {
       if (importFrom.isWildcardImport()) {
         Set<Symbol> importedModuleSymbols = projectLevelSymbolTable.getSymbolsFromModule(moduleName);
         if (importedModuleSymbols == null && moduleName != null && !moduleName.equals(fullyQualifiedModuleName)) {
-          importedModuleSymbols = TypeShed.symbolsForModule(moduleName);
+          importedModuleSymbols = TypeShed.symbolsForModule(moduleName).stream()
+            .map(importedSymbol -> currentScope().copySymbol(importedSymbol.name(), importedSymbol)).collect(Collectors.toSet());
         }
         if (importedModuleSymbols != null && !importedModuleSymbols.isEmpty()) {
           currentScope().createSymbolsFromWildcardImport(importedModuleSymbols, importFrom);
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/SymbolUtils.java b/python-frontend/src/main/java/org/sonar/python/semantic/SymbolUtils.java
@@ -286,6 +286,6 @@ public static Symbol typeshedSymbolWithFQN(String fullyQualifiedName) {
     String[] fqnSplitByDot = fullyQualifiedName.split("\\.");
     String localName = fqnSplitByDot[fqnSplitByDot.length - 1];
     Symbol symbol = TypeShed.symbolWithFQN(fullyQualifiedName);
-    return symbol == null ? new SymbolImpl(localName, fullyQualifiedName) : symbol;
+    return symbol == null ? new SymbolImpl(localName, fullyQualifiedName) : ((SymbolImpl) symbol).copyWithoutUsages();
   }
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolImplTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolImplTest.java
@@ -241,7 +241,7 @@ public void from_protobuf() throws TextFormat.ParseException {
     ClassSymbolImpl classSymbol = new ClassSymbolImpl(classSymbol(protobuf));
     assertThat(classSymbol.name()).isEqualTo("A");
     assertThat(classSymbol.fullyQualifiedName()).isEqualTo("mod.A");
-    assertThat(classSymbol.superClasses()).containsExactly(TypeShed.typeShedClass("object"));
+    assertThat(classSymbol.superClasses()).extracting(Symbol::fullyQualifiedName).containsExactly("object");
     assertThat(classSymbol.hasDecorators()).isTrue();
     assertThat(classSymbol.hasMetaClass()).isTrue();
     assertThat(classSymbol.metaclassFQN()).isEqualTo("abc.ABCMeta");
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/ProjectLevelSymbolTableTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/ProjectLevelSymbolTableTest.java
@@ -29,6 +29,7 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 import org.junit.Test;
+import org.sonar.plugins.python.api.symbols.AmbiguousSymbol;
 import org.sonar.plugins.python.api.symbols.ClassSymbol;
 import org.sonar.plugins.python.api.symbols.FunctionSymbol;
 import org.sonar.plugins.python.api.symbols.Symbol;
@@ -740,6 +741,42 @@ public void class_with_method_parameter_of_same_type() {
     assertThat(declaredType.getTypeClass()).isSameAs(classSymbol);
   }
 
+  @Test
+  public void no_stackoverflow_for_ambiguous_descriptor() {
+    String[] foo = {
+    "if cond:",
+    "  Ambiguous = ...",
+    "else:",
+    "  class Ambiguous(SomeParent):",
+    "    local_var = 'i'",
+    "    def func(param: Ambiguous):",
+    "      ..."
+    };
+    String[] bar = {
+      "from foo import *\n",
+    };
+    ProjectLevelSymbolTable projectSymbolTable = new ProjectLevelSymbolTable();
+    projectSymbolTable.addModule(parseWithoutSymbols(foo), "", pythonFile("foo.py"));
+    projectSymbolTable.addModule(parseWithoutSymbols(bar), "", pythonFile("bar.py"));
+
+    Set<Symbol> fooSymbols = projectSymbolTable.getSymbolsFromModule("foo");
+    assertThat(fooSymbols).hasSize(1);
+    AmbiguousSymbol symbolFromProjectTable = ((AmbiguousSymbol) fooSymbols.stream().findFirst().get());
+    assertThat(symbolFromProjectTable.fullyQualifiedName()).isEqualTo("foo.Ambiguous");
+    assertThat(symbolFromProjectTable.alternatives()).hasSize(2);
+    assertThat(symbolFromProjectTable.alternatives()).extracting(Symbol::kind).containsExactlyInAnyOrder(Symbol.Kind.CLASS, Symbol.Kind.OTHER);
+    ClassSymbol classSymbol = (ClassSymbol) symbolFromProjectTable.alternatives().stream().filter(s -> s.kind().equals(Symbol.Kind.CLASS)).findFirst().get();
+    assertThat(classSymbol.declaredMembers()).hasSize(2);
+    assertThat(classSymbol.declaredMembers()).extracting(Symbol::kind).containsExactlyInAnyOrder(Symbol.Kind.FUNCTION, Symbol.Kind.OTHER);
+
+    FileInput tree = parse(new SymbolTableBuilder("", pythonFile("bar.py"), projectSymbolTable), bar);
+    assertThat(tree.globalVariables()).hasSize(1);
+    AmbiguousSymbol localSymbol = (AmbiguousSymbol) tree.globalVariables().stream().findFirst().get();
+    assertThat(localSymbol.fullyQualifiedName()).isEqualTo("foo.Ambiguous");
+    assertThat(localSymbol.alternatives()).hasSize(2);
+    assertThat(localSymbol.alternatives()).extracting(Symbol::kind).containsExactlyInAnyOrder(Symbol.Kind.CLASS, Symbol.Kind.OTHER);
+  }
+
   @Test
   public void loop_in_inheritance_with_method_paraneters_of_same_type() {
     String[] foo = {
diff --git a/python-frontend/src/test/java/org/sonar/python/types/TypeShedTest.java b/python-frontend/src/test/java/org/sonar/python/types/TypeShedTest.java
@@ -66,7 +66,7 @@ public void classes() {
     assertThat(intClass.hasUnresolvedTypeHierarchy()).isFalse();
     assertThat(intClass.usages()).isEmpty();
     assertThat(intClass.declaredMembers()).allMatch(member -> member.usages().isEmpty());
-    assertThat(TypeShed.typeShedClass("bool").superClasses()).containsExactly(intClass);
+    assertThat(TypeShed.typeShedClass("bool").superClasses()).extracting(Symbol::fullyQualifiedName).containsExactly("int");
   }
 
   @Test
@@ -342,7 +342,7 @@ public void class_symbols_from_protobuf() throws TextFormat.ParseException {
       .containsExactlyInAnyOrder(tuple(Kind.CLASS, "mod.Base"), tuple(Kind.CLASS, "mod.C"), tuple(Kind.CLASS, "mod.D"));
 
     ClassSymbol C = (ClassSymbol) symbols.get("mod.C");
-    assertThat(C.superClasses()).containsExactly(TypeShed.typeShedClass("str"));
+    assertThat(C.superClasses()).extracting(Symbol::fullyQualifiedName).containsExactly("str");
     ClassSymbol D = (ClassSymbol) symbols.get("mod.D");
     assertThat(D.superClasses()).extracting(Symbol::kind, Symbol::fullyQualifiedName)
       .containsExactly(tuple(Kind.OTHER, "NOT_EXISTENT"));

Original file line number	Diff line number	Diff line change
`@@ -137,24 +137,26 @@ public Symbol getSymbol(@Nullable String fullyQualifiedName) {`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`public Symbol getSymbol(@Nullable String fullyQualifiedName, @Nullable String localSymbolName) {`
`140`		`- return getSymbol(fullyQualifiedName, localSymbolName, new HashMap<>());`
	`140`	`+ return getSymbol(fullyQualifiedName, localSymbolName, new HashMap<>(), new HashMap<>());`
`141`	`141`	`}`
`142`	`142`
`143`		`- public Symbol getSymbol(@Nullable String fullyQualifiedName, @Nullable String localSymbolName, Map<String, Symbol> createdSymbols) {`
	`143`	`+ public Symbol getSymbol(@Nullable String fullyQualifiedName, @Nullable String localSymbolName,`
	`144`	`+ Map<Descriptor, Symbol> createdSymbolsByDescriptor, Map<String, Symbol> createdSymbolsByFqn) {`
`144`	`145`	`if (fullyQualifiedName == null) return null;`
`145`	`146`	`Descriptor descriptor = globalDescriptorsByFQN().get(fullyQualifiedName);`
`146`		`- return descriptor == null ? null : DescriptorUtils.symbolFromDescriptor(descriptor, this, localSymbolName, createdSymbols);`
	`147`	`+ return descriptor == null ? null : DescriptorUtils.symbolFromDescriptor(descriptor, this, localSymbolName, createdSymbolsByDescriptor, createdSymbolsByFqn);`
`147`	`148`	`}`
`148`	`149`
`149`	`150`	`@CheckForNull`
`150`	`151`	`public Set<Symbol> getSymbolsFromModule(@Nullable String moduleName) {`
`151`	`152`	`Set<Descriptor> descriptors = globalDescriptorsByModuleName.get(moduleName);`
`152`		`- Map<String, Symbol> createdSymbols = new HashMap<>();`
`153`	`153`	`if (descriptors == null) {`
`154`	`154`	`return null;`
`155`	`155`	`}`
	`156`	`+ Map<Descriptor, Symbol> createdSymbolsByDescriptor = new HashMap<>();`
	`157`	`+ Map<String, Symbol> createdSymbolsByFqn = new HashMap<>();`
`156`	`158`	`return descriptors.stream()`
`157`		`- .map(desc -> DescriptorUtils.symbolFromDescriptor(desc, this, null, createdSymbols)).collect(Collectors.toSet());`
	`159`	`+ .map(desc -> DescriptorUtils.symbolFromDescriptor(desc, this, null, createdSymbolsByDescriptor, createdSymbolsByFqn)).collect(Collectors.toSet());`
`158`	`160`	`}`
`159`	`161`
`160`	`162`	`public boolean isDjangoView(@Nullable String fqn) {`
Original file line number	Diff line number	Diff line change
`@@ -82,15 +82,14 @@ void createBuiltinSymbol(String name, Map<String, Symbol> typeShedSymbols) {`
`82`	`82`
`83`	`83`	`void createSymbolsFromWildcardImport(Set<Symbol> importedSymbols, ImportFrom importFrom) {`
`84`	`84`	`importedSymbols.forEach(symbol -> {`
`85`		`- Symbol importedSymbol = copySymbol(symbol.name(), symbol);`
`86`		`- if (!isExistingSymbol(importedSymbol.name())) {`
`87`		`- symbols.add(importedSymbol);`
`88`		`- symbolsByName.put(symbol.name(), importedSymbol);`
`89`		`- ((SymbolImpl) importedSymbol).addUsage(importFrom, Usage.Kind.IMPORT);`
	`85`	`+ if (!isExistingSymbol(symbol.name())) {`
	`86`	`+ symbols.add(symbol);`
	`87`	`+ symbolsByName.put(symbol.name(), symbol);`
	`88`	`+ ((SymbolImpl) symbol).addUsage(importFrom, Usage.Kind.IMPORT);`
`90`	`89`	`} else {`
`91`	`90`	`SymbolImpl originalSymbol = resolve(symbol.name());`
`92`	`91`	`if (originalSymbol != null) {`
`93`		`- resetSymbolInfo(importedSymbol.fullyQualifiedName(), originalSymbol);`
	`92`	`+ resetSymbolInfo(symbol.fullyQualifiedName(), originalSymbol);`
`94`	`93`	`originalSymbol.addUsage(importFrom, Usage.Kind.IMPORT);`
`95`	`94`	`}`
`96`	`95`	`}`
`@@ -123,7 +122,7 @@ void addFunctionSymbol(FunctionDef functionDef, @Nullable String fullyQualifiedN`
`123`	`122`	`}`
`124`	`123`	`}`
`125`	`124`
`126`		`- private Symbol copySymbol(String symbolName, Symbol symbol) {`
	`125`	`+ public Symbol copySymbol(String symbolName, Symbol symbol) {`
`127`	`126`	`return copySymbol(symbolName, symbol, new HashSet<>());`
`128`	`127`	`}`
`129`	`128`
Original file line number	Diff line number	Diff line change
`@@ -286,6 +286,6 @@ public static Symbol typeshedSymbolWithFQN(String fullyQualifiedName) {`
`286`	`286`	`String[] fqnSplitByDot = fullyQualifiedName.split("\\.");`
`287`	`287`	`String localName = fqnSplitByDot[fqnSplitByDot.length - 1];`
`288`	`288`	`Symbol symbol = TypeShed.symbolWithFQN(fullyQualifiedName);`
`289`		`- return symbol == null ? new SymbolImpl(localName, fullyQualifiedName) : symbol;`
	`289`	`+ return symbol == null ? new SymbolImpl(localName, fullyQualifiedName) : ((SymbolImpl) symbol).copyWithoutUsages();`
`290`	`290`	`}`
`291`	`291`	`}`