diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java
new file mode 100644
index 00000000000..f701bbc2efa
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.lazy;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.psi.JetClassOrObject;
+import org.jetbrains.jet.lang.psi.JetDeclaration;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+
+public interface KotlinCodeAnalyzer {
+    ModuleDescriptor getRootModuleDescriptor();
+
+    @NotNull
+    ModuleConfiguration getModuleConfiguration();
+
+    @Nullable
+    NamespaceDescriptor getPackageDescriptor(@NotNull Name shortName);
+
+    @Nullable
+    NamespaceDescriptor getPackageDescriptorByFqName(FqName fqName);
+
+    @NotNull
+    ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject);
+
+    @NotNull
+    BindingContext getBindingContext();
+
+    @NotNull
+    DeclarationDescriptor resolveToDescriptor(JetDeclaration declaration);
+
+    /**
+     * Forces all descriptors to be resolved.
+     *
+     * Use this method when laziness plays against you, e.g. when lazy descriptors may be accessed in a multi-threaded setting
+     */
+    void forceResolveAll();
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java
index d0c1d58f902..899d4254344 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java
@@ -38,7 +38,7 @@ import java.util.List;
 
 import static org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils.safeNameForLazyResolve;
 
-public class ResolveSession {
+public class ResolveSession implements KotlinCodeAnalyzer {
     private static final Function<FqName, Name> NO_ALIASES = new Function<FqName, Name>() {
 
         @Override
@@ -128,6 +128,7 @@ public class ResolveSession {
         return specialClasses.apply(fqName);
     }
 
+    @Override
     public ModuleDescriptor getRootModuleDescriptor() {
         return module;
     }
@@ -137,16 +138,19 @@ public class ResolveSession {
         return storageManager;
     }
 
+    @Override
     @NotNull
     public ModuleConfiguration getModuleConfiguration() {
         return moduleConfiguration;
     }
 
+    @Override
     @Nullable
     public NamespaceDescriptor getPackageDescriptor(@NotNull Name shortName) {
         return rootPackage.getMemberScope().getNamespace(shortName);
     }
 
+    @Override
     @Nullable
     public NamespaceDescriptor getPackageDescriptorByFqName(FqName fqName) {
         if (fqName.isRoot()) {
@@ -162,6 +166,7 @@ public class ResolveSession {
         return current;
     }
 
+    @Override
     @NotNull
     public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject) {
         if (classOrObject.getParent() instanceof JetClassObject) {
@@ -195,6 +200,7 @@ public class ResolveSession {
         return classObjectDescriptor;
     }
 
+    @Override
     @NotNull
     public BindingContext getBindingContext() {
         return trace.getBindingContext();
@@ -210,6 +216,7 @@ public class ResolveSession {
         return declarationProviderFactory;
     }
 
+    @Override
     @NotNull
     public DeclarationDescriptor resolveToDescriptor(JetDeclaration declaration) {
         DeclarationDescriptor result = declaration.accept(new JetVisitor<DeclarationDescriptor, Void>() {
@@ -319,11 +326,7 @@ public class ResolveSession {
         return actualName;
     }
 
-    /**
-     * Forces all descriptors to be resolved.
-     *
-     * Use this method when laziness plays against you, e.g. when lazy descriptors may be accessed in a multi-threaded setting
-     */
+    @Override
     public void forceResolveAll() {
         rootPackage.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies<Void, Void>() {
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java
index 48116f6d6b1..8deea934c2c 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java
@@ -154,12 +154,12 @@ public class ResolveSessionUtils {
         return trace.getBindingContext();
     }
 
-    private static void delegationSpecifierAdditionalResolve(final ResolveSession resolveSession,
+    private static void delegationSpecifierAdditionalResolve(final KotlinCodeAnalyzer analyzer,
             final JetDelegationSpecifierList specifier, DelegatingBindingTrace trace, JetFile file) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getModuleConfiguration());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getModuleConfiguration());
 
         JetClassOrObject classOrObject = (JetClassOrObject) specifier.getParent();
-        LazyClassDescriptor descriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject);
+        LazyClassDescriptor descriptor = (LazyClassDescriptor) analyzer.resolveToDescriptor(classOrObject);
 
         // Activate resolving of supertypes
         descriptor.getTypeConstructor().getSupertypes();
@@ -206,14 +206,14 @@ public class ResolveSessionUtils {
     }
 
     private static boolean initializerAdditionalResolve(
-            ResolveSession resolveSession,
+            KotlinCodeAnalyzer analyzer,
             JetClassInitializer classInitializer,
             DelegatingBindingTrace trace,
             JetFile file
     ) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getModuleConfiguration());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getModuleConfiguration());
         JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class);
-        LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject);
+        LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) analyzer.resolveToDescriptor(classOrObject);
         bodyResolver.resolveAnonymousInitializers(classOrObject, classOrObjectDescriptor.getUnsubstitutedPrimaryConstructor(),
                 classOrObjectDescriptor.getScopeForPropertyInitializerResolution());
 
@@ -321,15 +321,15 @@ public class ResolveSessionUtils {
 
     @NotNull
     public static Collection<ClassDescriptor> getClassDescriptorsByFqName(
-                @NotNull ResolveSession resolveSession,
+                @NotNull KotlinCodeAnalyzer analyzer,
                 @NotNull FqName fqName
     ) {
-        return getClassOrObjectDescriptorsByFqName(resolveSession, fqName, false);
+        return getClassOrObjectDescriptorsByFqName(analyzer, fqName, false);
     }
 
     @NotNull
     public static Collection<ClassDescriptor> getClassOrObjectDescriptorsByFqName(
-            @NotNull ResolveSession resolveSession,
+            @NotNull KotlinCodeAnalyzer analyzer,
             @NotNull FqName fqName,
             boolean includeObjectDeclarations
     ) {
@@ -341,7 +341,7 @@ public class ResolveSessionUtils {
 
         FqName packageFqName = fqName.parent();
         while (true) {
-            NamespaceDescriptor packageDescriptor = resolveSession.getPackageDescriptorByFqName(packageFqName);
+            NamespaceDescriptor packageDescriptor = analyzer.getPackageDescriptorByFqName(packageFqName);
             if (packageDescriptor != null) {
                 FqName classInPackagePath = new FqName(QualifiedNamesUtil.tail(packageFqName, fqName));
                 Collection<ClassDescriptor> descriptors = getClassOrObjectDescriptorsByFqName(packageDescriptor, classInPackagePath,
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java
index fb4ea1ae0f6..ea6346613cb 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java
@@ -35,10 +35,9 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetImportDirective;
-import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.lazy.FileBasedDeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.lazy.LockBasedStorageManager;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -135,7 +134,7 @@ public class KotlinBuiltIns {
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    private final ResolveSession resolveSession;
+    private final KotlinCodeAnalyzer anazlyer;
     private final ModuleDescriptor builtInsModule;
 
     private volatile ImmutableSet<ClassDescriptor> nonPhysicalClasses;
@@ -172,7 +171,7 @@ public class KotlinBuiltIns {
     private KotlinBuiltIns(@NotNull Project project) {
         try {
             this.builtInsModule = new ModuleDescriptor(Name.special("<built-ins lazy module>"));
-            this.resolveSession = createLazyResolveSession(project);
+            this.anazlyer = createLazyResolveSession(project);
 
             this.functionClassesSet = computeIndexedClasses("Function", getFunctionTraitCount());
             this.extensionFunctionClassesSet = computeIndexedClasses("ExtensionFunction", getFunctionTraitCount());
@@ -215,13 +214,13 @@ public class KotlinBuiltIns {
 
         nonPhysicalClasses = computeNonPhysicalClasses();
 
-        resolveSession.forceResolveAll();
+        anazlyer.forceResolveAll();
 
-        AnalyzingUtils.throwExceptionOnErrors(resolveSession.getBindingContext());
+        AnalyzingUtils.throwExceptionOnErrors(anazlyer.getBindingContext());
     }
 
     @NotNull
-    private ResolveSession createLazyResolveSession(@NotNull Project project) throws IOException {
+    private KotlinCodeAnalyzer createLazyResolveSession(@NotNull Project project) throws IOException {
         List<JetFile> files = loadResourcesAsJetFiles(project, LIBRARY_FILES);
         LockBasedStorageManager storageManager = new LockBasedStorageManager();
         return new ResolveSession(
diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java
index 28a811b2e05..eff3cd5df36 100644
--- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java
+++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java
@@ -71,7 +71,7 @@ public abstract class AbstractLazyResolveTest extends JetLiteFixture {
             }
         });
 
-        ResolveSession resolveSession = LazyResolveTestUtil.resolveLazilyWithSession(files, getEnvironment());
+        KotlinCodeAnalyzer resolveSession = LazyResolveTestUtil.resolveLazilyWithSession(files, getEnvironment());
 
         NamespaceDescriptor actual = resolveSession.getPackageDescriptor(Name.identifier("test"));
         Assert.assertNotNull("Package 'test' was not found", actual);
diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java
index e0e942e93d6..c071ba035ac 100644
--- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java
+++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java
@@ -82,7 +82,7 @@ public class LazyResolveTestUtil {
         return module;
     }
 
-    public static ResolveSession resolveLazilyWithSession(List<JetFile> files, JetCoreEnvironment environment) {
+    public static KotlinCodeAnalyzer resolveLazilyWithSession(List<JetFile> files, JetCoreEnvironment environment) {
         JetTestUtils.newTrace(environment);
 
         ModuleDescriptor javaModule = new ModuleDescriptor(Name.special("<java module>"));
diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java
index c1b2e0a8c1b..8f6ef5153c7 100644
--- a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java
+++ b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java
@@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
+import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -347,14 +348,14 @@ public class JetShortNamesCache extends PsiShortNamesCache {
 
     public Collection<ClassDescriptor> getJetClassesDescriptors(
             @NotNull Condition<String> acceptedShortNameCondition,
-            @NotNull ResolveSession resolveSession
+            @NotNull KotlinCodeAnalyzer analyzer
     ) {
         Collection<ClassDescriptor> classDescriptors = new ArrayList<ClassDescriptor>();
 
         for (String fqName : JetFullClassNameIndex.getInstance().getAllKeys(project)) {
             FqName classFQName = new FqName(fqName);
             if (acceptedShortNameCondition.value(classFQName.shortName().getName())) {
-                classDescriptors.addAll(ResolveSessionUtils.getClassDescriptorsByFqName(resolveSession, classFQName));
+                classDescriptors.addAll(ResolveSessionUtils.getClassDescriptorsByFqName(analyzer, classFQName));
             }
         }
 
diff --git a/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java b/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java
index 9c62bdd6701..c6acc68412a 100644
--- a/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java
+++ b/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java
@@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
+import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.plugin.JetDescriptorIconProvider;
@@ -59,7 +59,7 @@ public final class DescriptorLookupConverter {
     private DescriptorLookupConverter() {}
 
     @NotNull
-    public static LookupElement createLookupElement(@NotNull ResolveSession resolveSession,
+    public static LookupElement createLookupElement(@NotNull KotlinCodeAnalyzer analyzer,
             @NotNull DeclarationDescriptor descriptor, @Nullable PsiElement declaration) {
         if (declaration != null) {
             MutableLookupElement javaLookupElement = createJavaLookupElementIfPossible(declaration);
@@ -75,7 +75,7 @@ public final class DescriptorLookupConverter {
         }
 
         LookupElementBuilder element = LookupElementBuilder.create(
-                new JetLookupObject(descriptor, resolveSession, declaration), descriptor.getName().getName());
+                new JetLookupObject(descriptor, analyzer, declaration), descriptor.getName().getName());
 
         String presentableText = descriptor.getName().getName();
         String typeText = "";
@@ -172,7 +172,7 @@ public final class DescriptorLookupConverter {
 
     @NotNull
     public static LookupElement createLookupElement(
-            @NotNull ResolveSession resolveSession,
+            @NotNull KotlinCodeAnalyzer analyzer,
             @NotNull BindingContext bindingContext,
             @NotNull DeclarationDescriptor descriptor) {
         if (descriptor instanceof CallableMemberDescriptor) {
@@ -183,17 +183,17 @@ public final class DescriptorLookupConverter {
             }
             descriptor = callableMemberDescriptor;
         }
-        return createLookupElement(resolveSession, descriptor, BindingContextUtils.descriptorToDeclaration(bindingContext, descriptor));
+        return createLookupElement(analyzer, descriptor, BindingContextUtils.descriptorToDeclaration(bindingContext, descriptor));
     }
 
     public static LookupElement[] collectLookupElements(
-            @NotNull ResolveSession resolveSession,
+            @NotNull KotlinCodeAnalyzer analyzer,
             @NotNull BindingContext bindingContext,
             @NotNull Iterable<DeclarationDescriptor> descriptors) {
         List<LookupElement> result = Lists.newArrayList();
 
         for (final DeclarationDescriptor descriptor : descriptors) {
-            result.add(createLookupElement(resolveSession, bindingContext, descriptor));
+            result.add(createLookupElement(analyzer, bindingContext, descriptor));
         }
 
         return result.toArray(new LookupElement[result.size()]);
diff --git a/idea/src/org/jetbrains/jet/plugin/completion/JetLookupObject.java b/idea/src/org/jetbrains/jet/plugin/completion/JetLookupObject.java
index 38dfa8e5864..97cd2895a5b 100644
--- a/idea/src/org/jetbrains/jet/plugin/completion/JetLookupObject.java
+++ b/idea/src/org/jetbrains/jet/plugin/completion/JetLookupObject.java
@@ -21,7 +21,7 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
+import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
 /**
@@ -35,14 +35,14 @@ public final class JetLookupObject {
     private final DeclarationDescriptor descriptor;
 
     @NotNull
-    private final ResolveSession resolveSession;
+    private final KotlinCodeAnalyzer analyzer;
 
     @Nullable
     private final PsiElement psiElement;
 
-    public JetLookupObject(@Nullable DeclarationDescriptor descriptor, @NotNull ResolveSession resolveSession, @Nullable PsiElement psiElement) {
+    public JetLookupObject(@Nullable DeclarationDescriptor descriptor, @NotNull KotlinCodeAnalyzer analyzer, @Nullable PsiElement psiElement) {
         this.descriptor = descriptor;
-        this.resolveSession = resolveSession;
+        this.analyzer = analyzer;
         this.psiElement = psiElement;
     }
 
@@ -79,7 +79,7 @@ public final class JetLookupObject {
 
         // Same descriptor - same lookup element
         if (descriptor != null && other.descriptor != null) {
-            if (resolveSession == other.resolveSession) {
+            if (analyzer == other.analyzer) {
                 if (descriptor.equals(other.descriptor)) {
                     return true;
                 }
diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java
index 8cec5ee2a16..b1dbd65916d 100644
--- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java
+++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java
@@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.lazy.FileBasedDeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.lazy.LockBasedStorageManager;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -207,7 +208,7 @@ public class JetSourceNavigationHelper {
                         return KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(fqName);
                     }
                 });
-        ResolveSession resolveSession = new ResolveSession(
+        KotlinCodeAnalyzer analyzer = new ResolveSession(
                 project,
                 storageManager,
                 new ModuleDescriptor(Name.special("<library module>")),
@@ -216,7 +217,7 @@ public class JetSourceNavigationHelper {
 
         for (JetNamedDeclaration candidate : candidates) {
             //noinspection unchecked
-            CallableDescriptor candidateDescriptor = (CallableDescriptor) resolveSession.resolveToDescriptor(candidate);
+            CallableDescriptor candidateDescriptor = (CallableDescriptor) analyzer.resolveToDescriptor(candidate);
             if (receiversMatch(decompiledDeclaration, candidateDescriptor)
                     && valueParametersTypesMatch(decompiledDeclaration, candidateDescriptor)
                     && typeParametersMatch((JetTypeParameterListOwner) decompiledDeclaration, candidateDescriptor.getTypeParameters())) {
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java
index c8ea76c1fee..da751f8c893 100644
--- a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java
@@ -46,6 +46,7 @@ import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.ImportPath;
+import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.plugin.JetBundle;
@@ -158,14 +159,14 @@ public class ImportClassAndFunFix extends JetHintAction<JetSimpleNameExpression>
     /*
      * Searches for possible class names in kotlin context and java facade.
      */
-    public static Collection<FqName> getClassNames(@NotNull String referenceName, @NotNull JetFile file, @NotNull ResolveSession resolveSession) {
+    public static Collection<FqName> getClassNames(@NotNull String referenceName, @NotNull JetFile file, @NotNull KotlinCodeAnalyzer analyzer) {
         Set<FqName> possibleResolveNames = Sets.newHashSet();
 
         if (!JsModuleDetector.isJsModule(file)) {
             possibleResolveNames.addAll(getClassesFromCache(referenceName, file));
         }
         else {
-            possibleResolveNames.addAll(getJetClasses(referenceName, file.getProject(), resolveSession));
+            possibleResolveNames.addAll(getJetClasses(referenceName, file.getProject(), analyzer));
         }
 
         // TODO: Do appropriate sorting
@@ -205,7 +206,7 @@ public class ImportClassAndFunFix extends JetHintAction<JetSimpleNameExpression>
         return PsiShortNamesCache.getInstance(jetFile.getProject());
     }
 
-    private static Collection<FqName> getJetClasses(@NotNull final String typeName, @NotNull Project project, @NotNull ResolveSession resolveSession) {
+    private static Collection<FqName> getJetClasses(@NotNull final String typeName, @NotNull Project project, @NotNull KotlinCodeAnalyzer resolveSession) {
         JetShortNamesCache cache = JetShortNamesCache.getKotlinInstance(project);
         Collection<ClassDescriptor> descriptors = cache.getJetClassesDescriptors(new Condition<String>() {
             @Override
diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java
index 658f1b19085..a7f63f713fd 100644
--- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java
+++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java
@@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
+import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade;
 import org.jetbrains.jet.plugin.stubindex.JetSuperClassIndex;
@@ -63,7 +63,7 @@ public class KotlinDirectInheritorsSearcher extends QueryExecutorBase<PsiClass,
                 for (JetClassOrObject candidate : candidates) {
                     if (!(candidate instanceof JetClass)) continue;
                     JetFile containingFile = (JetFile) candidate.getContainingFile();
-                    ResolveSession sessionForFile = WholeProjectAnalyzerFacade.getLazyResolveSessionForFile(containingFile);
+                    KotlinCodeAnalyzer sessionForFile = WholeProjectAnalyzerFacade.getLazyResolveSessionForFile(containingFile);
                     ClassDescriptor classDescriptor = (ClassDescriptor) sessionForFile.resolveToDescriptor(candidate);
                     for (JetType type : classDescriptor.getTypeConstructor().getSupertypes()) {
                         ClassifierDescriptor declarationDescriptor = type.getConstructor().getDeclarationDescriptor();