Changed API in ResolutionFacade to resolve to element to support 3 modes

idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/BodyResolveMode.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2014 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
+
+public enum class BodyResolveMode {
+    FULL
+    PARTIAL
+    PARTIAL_FOR_COMPLETION
+}

idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java

@@ -59,12 +59,12 @@ public abstract class ElementResolver {
 
     @NotNull
     public BindingContext getElementAdditionalResolve(@NotNull JetElement jetElement) {
-        return elementAdditionalResolve(jetElement, PartialBodyResolveProvider.NONE);
+        return elementAdditionalResolve(jetElement, jetElement, BodyResolveMode.FULL);
     }
 
     @NotNull
     public BindingContext resolveToElement(@NotNull JetElement jetElement) {
-        return resolveToElement(jetElement, false);
+        return resolveToElement(jetElement, BodyResolveMode.FULL);
     }
 
     @NotNull
@@ -73,7 +73,7 @@ public abstract class ElementResolver {
     }
 
     @NotNull
-    public BindingContext resolveToElement(@NotNull JetElement jetElement, boolean partialBodyResolve) {
+    public BindingContext resolveToElement(@NotNull JetElement jetElement, BodyResolveMode bodyResolveMode) {
         @SuppressWarnings("unchecked") JetElement elementOfAdditionalResolve = (JetElement) JetPsiUtil.getTopmostParentOfTypes(
                 jetElement,
                 JetNamedFunction.class,
@@ -93,12 +93,9 @@ public abstract class ElementResolver {
                 elementOfAdditionalResolve = jetElement;
             }
 
-            if (partialBodyResolve && elementOfAdditionalResolve instanceof JetDeclaration) {
+            if (bodyResolveMode != BodyResolveMode.FULL) {
                 //TODO: do not resolve with filter if whole body resolve cached already
-                PartialBodyResolveFilter filter = new PartialBodyResolveFilter(
-                        jetElement,
-                        (JetDeclaration) elementOfAdditionalResolve, probablyNothingCallableNames());
-                return elementAdditionalResolve(elementOfAdditionalResolve, filter);
+                return elementAdditionalResolve(elementOfAdditionalResolve, jetElement, bodyResolveMode);
             }
 
             return getElementAdditionalResolve(elementOfAdditionalResolve);
@@ -127,7 +124,8 @@ public abstract class ElementResolver {
     @NotNull
     protected BindingContext elementAdditionalResolve(
             @NotNull JetElement resolveElement,
-            @NotNull PartialBodyResolveProvider partialResolveProvider
+            @NotNull JetElement contextElement,
+            @NotNull BodyResolveMode bodyResolveMode
     ) {
         // All additional resolve should be done to separate trace
         BindingTrace trace = resolveSession.getStorageManager().createSafeTrace(
@@ -135,6 +133,18 @@ public abstract class ElementResolver {
 
         JetFile file = resolveElement.getContainingJetFile();
 
+        PartialBodyResolveProvider partialResolveProvider;
+        if (bodyResolveMode != BodyResolveMode.FULL && resolveElement instanceof JetDeclaration) {
+            partialResolveProvider = new PartialBodyResolveFilter(
+                    contextElement,
+                    (JetDeclaration) resolveElement,
+                    probablyNothingCallableNames(),
+                    bodyResolveMode == BodyResolveMode.PARTIAL_FOR_COMPLETION);
+        }
+        else {
+            partialResolveProvider = PartialBodyResolveProvider.NONE;
+        }
+
         if (resolveElement instanceof JetNamedFunction) {
             functionAdditionalResolve(resolveSession, (JetNamedFunction) resolveElement, trace, file, partialResolveProvider);
         }
@@ -165,7 +175,7 @@ public abstract class ElementResolver {
             typeConstraintAdditionalResolve(resolveSession, (JetTypeConstraint) resolveElement);
         }
         else if (resolveElement instanceof JetCodeFragment) {
-            codeFragmentAdditionalResolve(resolveSession, (JetCodeFragment) resolveElement, trace);
+            codeFragmentAdditionalResolve(resolveSession, (JetCodeFragment) resolveElement, trace, bodyResolveMode);
         }
         else if (PsiTreeUtil.getParentOfType(resolveElement, JetPackageDirective.class) != null) {
             packageRefAdditionalResolve(resolveSession, trace, resolveElement);
@@ -218,7 +228,8 @@ public abstract class ElementResolver {
     private void codeFragmentAdditionalResolve(
             ResolveSession resolveSession,
             JetCodeFragment codeFragment,
-            BindingTrace trace
+            BindingTrace trace,
+            BodyResolveMode bodyResolveMode
     ) {
         JetElement codeFragmentExpression = codeFragment.getContentElement();
         if (!(codeFragmentExpression instanceof JetExpression)) return;
@@ -238,7 +249,7 @@ public abstract class ElementResolver {
             if (!(contextElement instanceof JetExpression)) return;
 
             JetExpression contextExpression = (JetExpression) contextElement;
-            BindingContext contextForElement = resolveToElement((JetElement) contextElement, true);
+            BindingContext contextForElement = resolveToElement((JetElement) contextElement, bodyResolveMode);
 
             scopeForContextElement = contextForElement.get(BindingContext.RESOLUTION_SCOPE, contextExpression);
             dataFlowInfoForContextElement = getDataFlowInfo(contextForElement, contextExpression);

idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/PartialBodyResolveFilter.kt

@@ -35,7 +35,8 @@ import org.jetbrains.jet.lang.psi.psiUtil.isProbablyNothing
 class PartialBodyResolveFilter(
         elementToResolve: JetElement,
         private val declaration: JetDeclaration,
-        probablyNothingCallableNames: ProbablyNothingCallableNames
+        probablyNothingCallableNames: ProbablyNothingCallableNames,
+        forCompletion: Boolean
 ) : PartialBodyResolveProvider() {
 
     private val statementMarks = StatementMarks()
@@ -74,7 +75,7 @@ class PartialBodyResolveFilter(
             }
         })
 
-        statementMarks.mark(elementToResolve, MarkLevel.NEED_COMPLETION)
+        statementMarks.mark(elementToResolve, if (forCompletion) MarkLevel.NEED_COMPLETION else MarkLevel.NEED_REFERENCE_RESOLVE)
         declaration.blocks().forEach { processBlock(it) }
     }