SONARPY-3132 Fix synchronization on SymbolsModuleTypeProvider#convertModuleType(...) (#342)

GitOrigin-RevId: 05ee1e281e92613e75b9a6f15d03ebb849dc2d99

Author: Seppli11

python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ModuleType.java

@@ -19,6 +19,7 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.sonar.api.Beta;
@@ -39,18 +40,15 @@ public ModuleType(@Nullable String name,
     this.fullyQualifiedName = fullyQualifiedName;
     this.parent = parent;
     this.members = members;
-    this.subModules = new HashMap<>();
+    this.subModules = new ConcurrentHashMap<>();
     registerAsSubmoduleOfParent(parent);
   }
 
   private void registerAsSubmoduleOfParent(@Nullable ModuleType parent) {
     if (parent == null) {
       return;
     }
-    TypeWrapper subModule = parent.subModules.get(this.name);
-    if (subModule == null) {
-      parent.subModules.put(this.name, TypeWrapper.of(this));
-    }
+    parent.subModules.putIfAbsent(this.name, TypeWrapper.of(this));
   }
 
   public ModuleType(@Nullable String name) {

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

@@ -18,6 +18,8 @@
 
 import java.util.List;
 import java.util.Optional;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.stream.IntStream;
 import org.sonar.python.semantic.ProjectLevelSymbolTable;
 import org.sonar.python.types.v2.LazyTypeWrapper;
@@ -32,10 +34,13 @@ public class ProjectLevelTypeTable implements TypeTable {
   private final PythonType rootModule;
   private final LazyTypesContext lazyTypesContext;
 
+  private final Lock createOrResolveSubModuleLock;
+
   public ProjectLevelTypeTable(ProjectLevelSymbolTable projectLevelSymbolTable) {
     this.lazyTypesContext = new LazyTypesContext(this);
     this.symbolsModuleTypeProvider = new SymbolsModuleTypeProvider(projectLevelSymbolTable, lazyTypesContext);
     this.rootModule = this.symbolsModuleTypeProvider.createBuiltinModule();
+    this.createOrResolveSubModuleLock = new ReentrantLock();
   }
 
   @Override
@@ -76,16 +81,15 @@ public PythonType getType(List<String> typeFqnParts) {
 
           // The member of the module is a LazyType, which means it's a re-exported type from a submodule
           // We try to resolve the submodule instead
-          Optional<PythonType> subModule = moduleType.resolveSubmodule(part);
-          parent = subModule.orElseGet(() -> symbolsModuleTypeProvider.convertModuleType(moduleFqnParts, moduleType));
+          parent = createOrResolveSubModule(moduleFqnParts, moduleType);
           continue;
         }
       }
       resolvedMember = parent.resolveMember(part);
       if (resolvedMember.isPresent()) {
         parent = resolvedMember.get();
       } else if (parent instanceof ModuleType module) {
-        parent = symbolsModuleTypeProvider.convertModuleType(moduleFqnParts, module);
+        parent = createOrResolveSubModule(moduleFqnParts, module);
       } else {
         return PythonType.UNKNOWN;
       }
@@ -106,19 +110,27 @@ private static boolean shouldResolveImmediately(LazyTypeWrapper lazyTypeWrapper,
   public PythonType getModuleType(List<String> typeFqnParts) {
     var parent = rootModule;
     for (int i = 0; i < typeFqnParts.size(); i++) {
-      var part = typeFqnParts.get(i);
       var moduleFqnParts = IntStream.rangeClosed(0, i)
         .mapToObj(typeFqnParts::get)
         .toList();
       if (!(parent instanceof ModuleType moduleType)) {
         return PythonType.UNKNOWN;
       }
-      Optional<PythonType> resolvedSubmodule = moduleType.resolveSubmodule(part);
-      parent = resolvedSubmodule.orElseGet(() -> symbolsModuleTypeProvider.convertModuleType(moduleFqnParts, moduleType));
+      parent = createOrResolveSubModule(moduleFqnParts, moduleType);
     }
     return parent;
   }
 
+  private PythonType createOrResolveSubModule(List<String> moduleFqn, ModuleType parent) {
+    try {
+      createOrResolveSubModuleLock.lock();
+      String part = moduleFqn.get(moduleFqn.size() - 1);
+      return parent.resolveSubmodule(part).orElseGet(() -> symbolsModuleTypeProvider.convertModuleType(moduleFqn, parent));
+    } finally {
+      createOrResolveSubModuleLock.unlock();
+    }
+  }
+
   public LazyTypesContext lazyTypesContext() {
     return lazyTypesContext;
   }

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

@@ -60,7 +60,7 @@ public ModuleType createBuiltinModule() {
     return rootModule;
   }
 
-  public synchronized PythonType convertModuleType(List<String> moduleFqn, ModuleType parent) {
+  public PythonType convertModuleType(List<String> moduleFqn, ModuleType parent) {
     var moduleName = moduleFqn.get(moduleFqn.size() - 1);
     var moduleFqnString = getModuleFqnString(moduleFqn);
     Optional<ModuleType> result =  createModuleTypeFromProjectLevelSymbolTable(moduleName, moduleFqnString, parent)