Expose lazy scopes to enable calling forceResolveAllContents()

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

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.Importer;
+import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.resolve.JetModuleUtil;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -42,7 +43,7 @@ import java.util.Set;
 
 import static org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver.LookupMode;
 
-public class LazyImportScope implements JetScope {
+public class LazyImportScope implements JetScope, LazyEntity {
     private final ResolveSession resolveSession;
     private final PackageViewDescriptor packageDescriptor;
     private final ImportsProvider importsProvider;
@@ -158,6 +159,13 @@ public class LazyImportScope implements JetScope {
                 packageDescriptor.getFqName().isRoot());
     }
 
+    @Override
+    public void forceResolveAllContents() {
+        for (JetImportDirective importDirective : importsProvider.getAllImports()) {
+            getImportScope(importDirective, LookupMode.EVERYTHING);
+        }
+    }
+
     @Nullable
     private <D extends DeclarationDescriptor> D selectFirstFromImports(
             final Name name,

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

@@ -40,17 +40,17 @@ import java.util.List;
 public class ScopeProvider {
     private final ResolveSession resolveSession;
 
-    private final MemoizedFunctionToNotNull<JetFile, JetScope> fileScopes;
+    private final MemoizedFunctionToNotNull<JetFile, LazyImportScope> explicitImportScopes;
 
     private final NotNullLazyValue<JetScope> defaultImportsScope;
 
     public ScopeProvider(@NotNull ResolveSession resolveSession) {
         this.resolveSession = resolveSession;
 
-        this.fileScopes = resolveSession.getStorageManager().createMemoizedFunction(new Function1<JetFile, JetScope>() {
+        this.explicitImportScopes = resolveSession.getStorageManager().createMemoizedFunction(new Function1<JetFile, LazyImportScope>() {
             @Override
-            public JetScope invoke(@NotNull JetFile file) {
-                return createFileScope(file);
+            public LazyImportScope invoke(@NotNull JetFile file) {
+                return createExplicitImportScope(file);
             }
         });
 
@@ -62,30 +62,30 @@ public class ScopeProvider {
         });
     }
 
-    @NotNull
-    public JetScope getFileScope(JetFile file) {
-        return fileScopes.invoke(file);
-    }
-
-    @NotNull
-    private JetScope createFileScope(@NotNull JetFile file) {
-        PackageViewDescriptor packageDescriptor = getFilePackageDescriptor(file);
-
-        JetScope importsScope = LazyImportScope.createImportScopeForFile(
+    private LazyImportScope createExplicitImportScope(@NotNull JetFile file) {
+        return LazyImportScope.createImportScopeForFile(
                 resolveSession,
-                packageDescriptor,
+                getFilePackageDescriptor(file),
                 file,
                 resolveSession.getTrace(),
                 "Lazy Imports Scope for file " + file.getName());
+    }
 
+    @NotNull
+    public JetScope getFileScope(@NotNull JetFile file) {
         return new ChainedScope(resolveSession.getPackageFragment(JetPsiUtil.getFQName(file)),
                                 "File scope: " + file.getName(),
-                                packageDescriptor.getMemberScope(),
+                                getFilePackageDescriptor(file).getMemberScope(),
                                 JetModuleUtil.getSubpackagesOfRootScope(resolveSession.getModuleDescriptor()),
-                                importsScope,
+                                explicitImportScopes.invoke(file),
                                 defaultImportsScope.invoke());
     }
 
+    @NotNull
+    public LazyImportScope getExplicitImportsScopeForFile(@NotNull JetFile file) {
+        return explicitImportScopes.invoke(file);
+    }
+
     private JetScope createScopeWithDefaultImports() {
         PackageViewDescriptor rootPackage = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT);
         if (rootPackage == null) {

idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java

@@ -145,10 +145,8 @@ public class ResolveElementCache {
         }
         else if (resolveElement instanceof JetImportDirective) {
             JetImportDirective importDirective = (JetImportDirective) resolveElement;
-            JetScope scope = resolveSession.getScopeProvider().getFileScope((JetFile) importDirective.getContainingFile());
-
-            // Get all descriptors to force resolving all imports
-            scope.getAllDescriptors();
+            LazyImportScope scope = resolveSession.getScopeProvider().getExplicitImportsScopeForFile((JetFile) importDirective.getContainingFile());
+            scope.forceResolveAllContents();
         }
         else if (resolveElement instanceof JetAnnotationEntry) {
             annotationAdditionalResolve(resolveSession, (JetAnnotationEntry) resolveElement);