From a2c66f7cc41f89814ea8bf39b033d47cff4f27d3 Mon Sep 17 00:00:00 2001
From: Andrey Breslav <andrey.breslav@jetbrains.com>
Date: Thu, 26 Sep 2013 11:05:17 -0700
Subject: [PATCH] Using lazy resolve when building light classes

---
 .../lazy/descriptors/LazyClassDescriptor.java |  1 +
 .../IDELightClassGenerationSupport.java       | 52 +++++++++++++++++--
 2 files changed, 48 insertions(+), 5 deletions(-)

diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java
index f94107a7b79..3a903beda33 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java
@@ -96,6 +96,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyEnti
         if (classLikeInfo.getCorrespondingClassOrObject() != null) {
             this.resolveSession.getTrace().record(BindingContext.CLASS, classLikeInfo.getCorrespondingClassOrObject(), this);
         }
+        this.resolveSession.getTrace().record(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, DescriptorUtils.getFqName(this), this);
 
         this.originalClassInfo = classLikeInfo;
         this.declarationProvider = resolveSession.getDeclarationProviderFactory().getClassMemberDeclarationProvider(classLikeInfo);
diff --git a/idea/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java b/idea/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java
index c719dbbbc20..ec9a3279e4b 100644
--- a/idea/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java
+++ b/idea/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java
@@ -18,6 +18,7 @@ package org.jetbrains.jet.plugin.caches.resolve;
 
 import com.google.common.collect.Sets;
 import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.libraries.LibraryUtil;
 import com.intellij.openapi.util.Condition;
@@ -34,37 +35,78 @@ import org.jetbrains.jet.asJava.LightClassGenerationSupport;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
+import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.plugin.libraries.JetSourceNavigationHelper;
+import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.stubindex.JetAllPackagesIndex;
 import org.jetbrains.jet.plugin.stubindex.JetClassByPackageIndex;
 import org.jetbrains.jet.plugin.stubindex.JetFullClassNameIndex;
 import org.jetbrains.jet.util.QualifiedNamesUtil;
+import org.jetbrains.jet.utils.Profiler;
 
-import java.util.Collection;
-import java.util.Set;
+import java.util.*;
 
 import static org.jetbrains.jet.plugin.stubindex.JetSourceFilterScope.kotlinSources;
 
 public class IDELightClassGenerationSupport extends LightClassGenerationSupport {
 
+    private static final Logger LOG = Logger.getInstance(IDELightClassGenerationSupport.class);
+
+    private static boolean USE_LAZY = true;
+
     public static IDELightClassGenerationSupport getInstanceForIDE(@NotNull Project project) {
         return (IDELightClassGenerationSupport) ServiceManager.getService(project, LightClassGenerationSupport.class);
     }
 
     private final Project project;
 
+    private final Comparator<JetFile> jetFileComparator;
+
     public IDELightClassGenerationSupport(@NotNull Project project) {
         this.project = project;
+        final GlobalSearchScope searchScope = GlobalSearchScope.allScope(project);
+        this.jetFileComparator = new Comparator<JetFile>() {
+            @Override
+            public int compare(@NotNull JetFile o1, @NotNull JetFile o2) {
+                VirtualFile f1 = o1.getVirtualFile();
+                VirtualFile f2 = o2.getVirtualFile();
+                if (f1 == f2) return 0;
+                if (f1 == null) return -1;
+                if (f2 == null) return 1;
+                return searchScope.compare(f1, f2);
+            }
+        };
     }
 
     @NotNull
     @Override
     public LightClassConstructionContext analyzeRelevantCode(@NotNull Collection<JetFile> files) {
-        KotlinCacheManager cacheManager = KotlinCacheManager.getInstance(project);
-        KotlinDeclarationsCache declarationsCache = cacheManager.getPossiblyIncompleteDeclarationsForLightClassGeneration();
-        return new LightClassConstructionContext(declarationsCache.getBindingContext(), null);
+        if (files.isEmpty()) {
+            return new LightClassConstructionContext(BindingContext.EMPTY, null);
+        }
+
+        List<JetFile> sortedFiles = new ArrayList<JetFile>(files);
+        Collections.sort(sortedFiles, jetFileComparator);
+
+        Profiler p = Profiler.create((USE_LAZY ? "lazy" : "eager") + "analyze", LOG).start();
+        try {
+            if (USE_LAZY) {
+                ResolveSessionForBodies session = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(sortedFiles.get(0));
+                session.forceResolveAll();
+                return new LightClassConstructionContext(session.getBindingContext(), null);
+            }
+            else {
+                KotlinCacheManager cacheManager = KotlinCacheManager.getInstance(project);
+                KotlinDeclarationsCache declarationsCache = cacheManager.getPossiblyIncompleteDeclarationsForLightClassGeneration();
+                return new LightClassConstructionContext(declarationsCache.getBindingContext(), null);
+            }
+        }
+        finally {
+            p.end();
+        }
     }
 
     @NotNull