Guard construction of imports index under common lock

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ImportsProvider.java

@@ -17,29 +17,35 @@
 package org.jetbrains.jet.lang.resolve.lazy;
 
 import com.google.common.collect.*;
+import com.intellij.openapi.util.Computable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.ImportPath;
+import org.jetbrains.jet.lang.resolve.lazy.storage.NotNullLazyValue;
+import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
-import java.util.*;
+import java.util.List;
+import java.util.Set;
 
 class ImportsProvider {
     private final List<JetImportDirective> importDirectives;
+    private final NotNullLazyValue<NameToImportsCache> importsCacheValue;
 
-    private ListMultimap<Name, JetImportDirective> nameToDirectives = null;
+    public ImportsProvider(StorageManager storageManager, final List<JetImportDirective> importDirectives) {
-    private List<JetImportDirective> allUnderImports = null;
-    private boolean indexed;
-
-    public ImportsProvider(List<JetImportDirective> importDirectives) {
         this.importDirectives = importDirectives;
+        this.importsCacheValue = storageManager.createLazyValue(new Computable<NameToImportsCache>() {
+            @Override
+            public NameToImportsCache compute() {
+                return NameToImportsCache.createIndex(importDirectives);
+            }
+        });
     }
 
     @NotNull
     public List<JetImportDirective> getImports(@NotNull Name name) {
-        createIndex();
+        return importsCacheValue.compute().getImports(name);
-        return nameToDirectives.containsKey(name) ? nameToDirectives.get(name) : allUnderImports;
     }
 
     @NotNull
@@ -47,11 +53,20 @@ class ImportsProvider {
         return importDirectives;
     }
 
-    private void createIndex() {
+    private static class NameToImportsCache {
-        if (indexed) {
+        private final ListMultimap<Name, JetImportDirective> nameToDirectives;
-            return;
+        private final List<JetImportDirective> allUnderImports;
+
+        private NameToImportsCache(ListMultimap<Name, JetImportDirective> directives, List<JetImportDirective> imports) {
+            nameToDirectives = directives;
+            allUnderImports = imports;
         }
 
+        private List<JetImportDirective> getImports(@NotNull Name name) {
+            return nameToDirectives.containsKey(name) ? nameToDirectives.get(name) : allUnderImports;
+        }
+
+        private static NameToImportsCache createIndex(List<JetImportDirective> importDirectives) {
             ImmutableListMultimap.Builder<Name, JetImportDirective> namesToRelativeImportsBuilder = ImmutableListMultimap.builder();
 
             Set<Name> processedAliases = Sets.newHashSet();
@@ -87,9 +102,7 @@ class ImportsProvider {
                 }
             }
 
-        allUnderImports = ImmutableList.copyOf(processedAllUnderImports);
+            return new NameToImportsCache(namesToRelativeImportsBuilder.build(), ImmutableList.copyOf(processedAllUnderImports));
-        nameToDirectives = namesToRelativeImportsBuilder.build();
+        }
-
-        indexed = true;
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java

@@ -126,7 +126,7 @@ public class LazyImportScope implements JetScope {
     ) {
         this.resolveSession = resolveSession;
         this.packageDescriptor = packageDescriptor;
-        this.importsProvider = new ImportsProvider(imports);
+        this.importsProvider = new ImportsProvider(resolveSession.getStorageManager(), imports);
         this.traceForImportResolve = traceForImportResolve;
         this.debugName = debugName;