diff --git a/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/BodyResolveMode.kt b/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/BodyResolveMode.kt new file mode 100644 index 00000000000..bb4aa5fc469 --- /dev/null +++ b/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 +} diff --git a/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java b/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java index 5269ed5f2db..b6fe9259fbc 100644 --- a/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java +++ b/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); diff --git a/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/PartialBodyResolveFilter.kt b/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/PartialBodyResolveFilter.kt index 4d470e57f69..d2e2c149ea1 100644 --- a/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/PartialBodyResolveFilter.kt +++ b/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) } } diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java index 2be96cd68ff..8c03fd3c739 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java @@ -35,14 +35,15 @@ import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode; import org.jetbrains.jet.lang.resolve.lazy.ForceResolveUtil; import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.plugin.decompiler.navigation.JetSourceNavigationHelper; import org.jetbrains.jet.plugin.project.ResolveSessionForBodies; -import org.jetbrains.jet.plugin.stubindex.JetTopLevelClassByPackageIndex; import org.jetbrains.jet.plugin.stubindex.JetFullClassNameIndex; +import org.jetbrains.jet.plugin.stubindex.JetTopLevelClassByPackageIndex; import org.jetbrains.jet.plugin.stubindex.PackageIndexUtil; import java.util.*; @@ -84,7 +85,7 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport KotlinCacheService.OBJECT$.getInstance(classOrObject.getProject()).getLazyResolveSession(classOrObject); if (classOrObject.isLocal()) { - BindingContext bindingContext = session.resolveToElement(classOrObject); + BindingContext bindingContext = session.resolveToElement(classOrObject, BodyResolveMode.FULL); ClassDescriptor descriptor = bindingContext.get(BindingContext.CLASS, classOrObject); if (descriptor == null) { diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt index f74b8d63a4a..78716d224ee 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt @@ -38,6 +38,7 @@ import org.jetbrains.jet.plugin.util.ProjectRootsUtil import org.jetbrains.jet.lang.descriptors.ModuleDescriptor import org.jetbrains.jet.lang.psi.JetDeclaration import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode private val LOG = Logger.getInstance(javaClass()) @@ -49,12 +50,8 @@ public class KotlinCacheService(val project: Project) { public fun getResolutionFacade(elements: List): ResolutionFacade { val cache = getCacheToAnalyzeFiles(elements.map { it.getContainingJetFile() }) return object : ResolutionFacade { - override fun analyze(element: JetElement): BindingContext { - return cache.getLazyResolveSession(element).resolveToElement(element) - } - - override fun analyzeWithPartialBodyResolve(element: JetElement): BindingContext { - return cache.getLazyResolveSession(element).resolveToElementWithPartialBodyResolve(element) + override fun analyze(element: JetElement, bodyResolveMode: BodyResolveMode): BindingContext { + return cache.getLazyResolveSession(element).resolveToElement(element, bodyResolveMode) } override fun findModuleDescriptor(element: JetElement): ModuleDescriptor { diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt index 0ad4fcf9940..c9cbc927bfe 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt @@ -65,6 +65,7 @@ import org.jetbrains.jet.plugin.project.TargetPlatformDetector import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor import org.jetbrains.jet.lang.resolve.calls.smartcasts.DataFlowInfo import org.jetbrains.jet.lang.resolve.scopes.JetScope +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode public trait CacheExtension { public val platform: TargetPlatform @@ -292,7 +293,7 @@ private object KotlinResolveDataProvider { else { if (contextElement !is JetExpression) return BindingContext.EMPTY - val contextForElement = contextElement.getResolutionFacade().analyzeWithPartialBodyResolve(contextElement) + val contextForElement = contextElement.getResolutionFacade().analyze(contextElement, BodyResolveMode.PARTIAL_FOR_COMPLETION) //TODO: discuss it scopeForContextElement = contextForElement[BindingContext.RESOLUTION_SCOPE, contextElement] dataFlowInfo = contextForElement.getDataFlowInfo(contextElement) diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/ResolutionFacade.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/ResolutionFacade.kt index 4e6df6847f1..d8c01ac7027 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/ResolutionFacade.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/ResolutionFacade.kt @@ -22,12 +22,11 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor import org.jetbrains.jet.lang.psi.JetDeclaration import org.jetbrains.jet.analyzer.AnalysisResult +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode public trait ResolutionFacade { - public fun analyze(element: JetElement): BindingContext - - public fun analyzeWithPartialBodyResolve(element: JetElement): BindingContext + public fun analyze(element: JetElement, bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL): BindingContext public fun analyzeFullyAndGetResult(elements: Collection): AnalysisResult diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java index 2ee26db09e7..c57f78e441b 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java @@ -28,11 +28,7 @@ import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; -import org.jetbrains.jet.lang.resolve.lazy.DefaultNothingCallableNames; -import org.jetbrains.jet.lang.resolve.lazy.ElementResolver; -import org.jetbrains.jet.lang.resolve.lazy.ProbablyNothingCallableNames; -import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; +import org.jetbrains.jet.lang.resolve.lazy.*; import org.jetbrains.jet.plugin.stubindex.JetProbablyNothingFunctionShortNameIndex; import org.jetbrains.jet.plugin.stubindex.JetProbablyNothingPropertyShortNameIndex; import org.jetbrains.jet.storage.LazyResolveStorageManager; @@ -62,7 +58,7 @@ public class ResolveElementCache extends ElementResolver { manager.createWeaklyRetainedMemoizedFunction(new Function1() { @Override public BindingContext invoke(JetElement jetElement) { - return elementAdditionalResolve(jetElement, PartialBodyResolveProvider.NONE); + return elementAdditionalResolve(jetElement, jetElement, BodyResolveMode.FULL); } }); diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveSessionForBodies.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveSessionForBodies.java index 99075a566e9..b2c24375844 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveSessionForBodies.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveSessionForBodies.java @@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode; import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; @@ -50,12 +51,8 @@ public class ResolveSessionForBodies implements KotlinCodeAnalyzer { } @NotNull - public BindingContext resolveToElement(JetElement element) { - return resolveElementCache.resolveToElement(element, false); - } - - public BindingContext resolveToElementWithPartialBodyResolve(JetElement element) { - return resolveElementCache.resolveToElement(element, true); + public BindingContext resolveToElement(JetElement element, BodyResolveMode bodyResolveMode) { + return resolveElementCache.resolveToElement(element, bodyResolveMode); } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/actions/internal/CheckPartialBodyResolveAction.kt b/idea/src/org/jetbrains/jet/plugin/actions/internal/CheckPartialBodyResolveAction.kt index 7ab875795bd..1e27ecb5c83 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/internal/CheckPartialBodyResolveAction.kt +++ b/idea/src/org/jetbrains/jet/plugin/actions/internal/CheckPartialBodyResolveAction.kt @@ -53,6 +53,7 @@ import org.jetbrains.jet.lang.psi.JetContainerNode import org.jetbrains.jet.lang.psi.JetDeclaration import org.jetbrains.jet.lang.psi.psiUtil.siblings import org.jetbrains.jet.utils.addToStdlib.firstIsInstanceOrNull +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode public class CheckPartialBodyResolveAction : AnAction() { override fun actionPerformed(e: AnActionEvent) { @@ -74,7 +75,7 @@ public class CheckPartialBodyResolveAction : AnAction() { progressIndicator?.setText2(file.getVirtualFile().getPath()) val partialResolveDump = dumpResolve(file) {(element, resolutionFacade) -> - resolutionFacade.analyzeWithPartialBodyResolve(element) + resolutionFacade.analyze(element, BodyResolveMode.PARTIAL) } val goldDump = dumpResolve(file) {(element, resolutionFacade) -> resolutionFacade.analyze(element) diff --git a/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt b/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt index 97d743b0330..b304e1b7089 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt @@ -43,6 +43,7 @@ import org.jetbrains.jet.plugin.util.makeNotNullable import org.jetbrains.jet.plugin.util.CallType import org.jetbrains.jet.plugin.completion.isVisible import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindExclude +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode class CompletionSessionConfiguration( val completeNonImportedDeclarations: Boolean, @@ -60,7 +61,7 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess private val file = position.getContainingFile() as JetFile protected val resolutionFacade: ResolutionFacade = file.getResolutionFacade() protected val moduleDescriptor: ModuleDescriptor = resolutionFacade.findModuleDescriptor(file) - protected val bindingContext: BindingContext? = jetReference?.let { resolutionFacade.analyzeWithPartialBodyResolve(it.expression) } + protected val bindingContext: BindingContext? = jetReference?.let { resolutionFacade.analyze(it.expression, BodyResolveMode.PARTIAL_FOR_COMPLETION) } protected val inDescriptor: DeclarationDescriptor? = jetReference?.let { bindingContext!!.get(BindingContext.RESOLUTION_SCOPE, it.expression)?.getContainingDeclaration() } // set prefix matcher here to override default one which relies on CompletionUtil.findReferencePrefix() diff --git a/idea/src/org/jetbrains/jet/plugin/completion/KotlinCompletionContributor.kt b/idea/src/org/jetbrains/jet/plugin/completion/KotlinCompletionContributor.kt index 5c0aa33ceef..ec521d4d851 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/KotlinCompletionContributor.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/KotlinCompletionContributor.kt @@ -58,6 +58,7 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor import org.jetbrains.jet.lang.descriptors.ClassDescriptor import org.jetbrains.jet.lang.descriptors.ClassKind import org.jetbrains.jet.plugin.caches.resolve.getResolutionFacade +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode public class KotlinCompletionContributor : CompletionContributor() { @@ -285,7 +286,7 @@ public class KotlinCompletionContributor : CompletionContributor() { assert(balance > 0) val nameRef = nameToken.getParent() as? JetNameReferenceExpression ?: return null - val bindingContext = nameRef.getResolutionFacade().analyzeWithPartialBodyResolve(nameRef) //TODO: analyze with "resolve" mode instead of "completion" + val bindingContext = nameRef.getResolutionFacade().analyze(nameRef, BodyResolveMode.PARTIAL) val target = bindingContext[BindingContext.REFERENCE_TARGET, nameRef] val targets = if (target != null) { listOf(target) diff --git a/idea/src/org/jetbrains/jet/plugin/completion/handlers/GenerateLambda.kt b/idea/src/org/jetbrains/jet/plugin/completion/handlers/GenerateLambda.kt index dd64f842ac3..7dbccdee1ea 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/handlers/GenerateLambda.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/handlers/GenerateLambda.kt @@ -40,6 +40,7 @@ import org.jetbrains.jet.plugin.caches.resolve.getResolutionFacade import org.jetbrains.jet.plugin.util.application.runWriteAction import org.jetbrains.jet.plugin.refactoring.EmptyValidator import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode fun insertLambdaTemplate(context: InsertionContext, placeholderRange: TextRange, lambdaType: JetType) { val explicitParameterTypes = needExplicitParameterTypes(context, placeholderRange, lambdaType) @@ -84,7 +85,7 @@ private fun needExplicitParameterTypes(context: InsertionContext, placeholderRan if (expression == null) return false val resolutionFacade = file.getResolutionFacade() - val bindingContext = resolutionFacade.analyzeWithPartialBodyResolve(expression) + val bindingContext = resolutionFacade.analyze(expression, BodyResolveMode.PARTIAL) val expectedInfos = ExpectedInfos(bindingContext, resolutionFacade).calculate(expression) ?: return false val functionTypes = expectedInfos.map { it.type }.filter { KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(it) }.toSet() if (functionTypes.size <= 1) return false diff --git a/idea/src/org/jetbrains/jet/plugin/completion/handlers/KotlinClassInsertHandler.kt b/idea/src/org/jetbrains/jet/plugin/completion/handlers/KotlinClassInsertHandler.kt index 0e46676a337..63260f96fa0 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/handlers/KotlinClassInsertHandler.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/handlers/KotlinClassInsertHandler.kt @@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.psi.JetNameReferenceExpression import org.jetbrains.jet.plugin.caches.resolve.getResolutionFacade import org.jetbrains.jet.lang.resolve.BindingContext import org.jetbrains.jet.lang.resolve.DescriptorUtils +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode public object KotlinClassInsertHandler : BaseDeclarationInsertHandler() { override fun handleInsert(context: InsertionContext, item: LookupElement) { @@ -49,7 +50,7 @@ public object KotlinClassInsertHandler : BaseDeclarationInsertHandler() { val token = file.findElementAt(startOffset) val nameRef = token.getParent() as? JetNameReferenceExpression if (nameRef != null) { - val bindingContext = nameRef.getResolutionFacade().analyzeWithPartialBodyResolve(nameRef) + val bindingContext = nameRef.getResolutionFacade().analyze(nameRef, BodyResolveMode.PARTIAL) val target = bindingContext[BindingContext.REFERENCE_TARGET, nameRef] as? ClassDescriptor if (target != null && DescriptorUtils.getFqNameSafe(target).asString() == qualifiedName) return } diff --git a/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java b/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java index c77818b7ffb..9cfc84b6775 100644 --- a/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java @@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils; import org.jetbrains.jet.lang.resolve.JetVisibilityChecker; +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindExclude; import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter; @@ -239,7 +240,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith StringBuilder builder = new StringBuilder(); PsiElement owner = context.getParameterOwner(); - BindingContext bindingContext = resolutionFacade.analyze((JetElement) owner); + BindingContext bindingContext = resolutionFacade.analyze((JetElement) owner, BodyResolveMode.FULL); for (int i = 0; i < valueParameters.size(); ++i) { if (i != 0) { @@ -383,7 +384,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith } ResolutionFacade resolutionFacade = ResolvePackage.getResolutionFacade(callNameExpression.getContainingJetFile()); - BindingContext bindingContext = resolutionFacade.analyze(callNameExpression); + BindingContext bindingContext = resolutionFacade.analyze(callNameExpression, BodyResolveMode.FULL); JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, callNameExpression); final DeclarationDescriptor placeDescriptor; diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/inline/KotlinInlineValHandler.java b/idea/src/org/jetbrains/jet/plugin/refactoring/inline/KotlinInlineValHandler.java index 7ac65f74431..5e226fdf290 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/inline/KotlinInlineValHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/inline/KotlinInlineValHandler.java @@ -55,6 +55,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.calls.callUtil.CallUtilPackage; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lexer.JetTokens; @@ -303,7 +304,7 @@ public class KotlinInlineValHandler extends InlineActionHandler { @NotNull ResolutionFacade resolutionFacade ) { JetFunctionLiteral functionLiteral = functionLiteralExpression.getFunctionLiteral(); - BindingContext context = resolutionFacade.analyze(functionLiteralExpression); + BindingContext context = resolutionFacade.analyze(functionLiteralExpression, BodyResolveMode.FULL); for (Diagnostic diagnostic : context.getDiagnostics()) { DiagnosticFactory factory = diagnostic.getFactory(); PsiElement element = diagnostic.getPsiElement(); @@ -323,7 +324,7 @@ public class KotlinInlineValHandler extends InlineActionHandler { ResolutionFacade resolutionFacade = ResolvePackage.getResolutionFacade(containingFile); for (JetExpression inlinedExpression : inlinedExpressions) { - BindingContext context = resolutionFacade.analyze(inlinedExpression); + BindingContext context = resolutionFacade.analyze(inlinedExpression, BodyResolveMode.FULL); Call call = CallUtilPackage.getCallWithAssert(inlinedExpression, context); JetElement callElement = call.getCallElement(); diff --git a/idea/tests/org/jetbrains/jet/resolve/AbstractPartialBodyResolveTest.kt b/idea/tests/org/jetbrains/jet/resolve/AbstractPartialBodyResolveTest.kt index e652f6851ba..f6ccd8cd60d 100644 --- a/idea/tests/org/jetbrains/jet/resolve/AbstractPartialBodyResolveTest.kt +++ b/idea/tests/org/jetbrains/jet/resolve/AbstractPartialBodyResolveTest.kt @@ -41,6 +41,7 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory import com.intellij.psi.util.PsiTreeUtil import org.jetbrains.jet.lang.psi.JetReferenceExpression import org.jetbrains.jet.lang.psi.psiUtil.getReceiverExpression +import org.jetbrains.jet.lang.resolve.lazy.BodyResolveMode public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtureTestCase() { override fun getTestDataPath() = JetTestCaseBuilder.getHomeDirectory() @@ -65,7 +66,7 @@ public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtur val resolutionFacade = file.getResolutionFacade() // optimized resolve - val (target1, type1, processedStatements1) = doResolve(expression, resolutionFacade.analyzeWithPartialBodyResolve(expression)) + val (target1, type1, processedStatements1) = doResolve(expression, resolutionFacade.analyze(expression, BodyResolveMode.PARTIAL_FOR_COMPLETION)) // full body resolve val (target2, type2, processedStatements2) = doResolve(expression, resolutionFacade.analyze(expression))