From 35766dfa20c858cfca002f0884f95f2daccead1e Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 6 Nov 2014 21:25:52 +0200 Subject: [PATCH] Additional/forced resolve for lazy types --- .../jetbrains/jet/checkers/DebugInfoUtil.java | 16 +++++++++++----- .../jetbrains/jet/lang/resolve/TypeResolver.kt | 9 ++++++++- .../jet/lang/resolve/lazy/ForceResolveUtil.java | 13 +++++++++++-- .../jet/lang/resolve/lazy/ElementResolver.java | 12 +++++------- .../AbstractInsertImportOnPasteTest.java | 6 ++++++ 5 files changed, 41 insertions(+), 15 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/checkers/DebugInfoUtil.java b/compiler/frontend/src/org/jetbrains/jet/checkers/DebugInfoUtil.java index 33f23929efe..022d1420358 100644 --- a/compiler/frontend/src/org/jetbrains/jet/checkers/DebugInfoUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/checkers/DebugInfoUtil.java @@ -24,8 +24,8 @@ import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetNodeTypes; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory; import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -44,13 +44,17 @@ public class DebugInfoUtil { private static final TokenSet EXCLUDED = TokenSet.create( COLON, AS_KEYWORD, AS_SAFE, IS_KEYWORD, NOT_IS, OROR, ANDAND, EQ, EQEQEQ, EXCLEQEQEQ, ELVIS, EXCLEXCL, IN_KEYWORD, NOT_IN); - public interface DebugInfoReporter { + public abstract static class DebugInfoReporter { - void reportElementWithErrorType(@NotNull JetReferenceExpression expression); + public void preProcessReference(@NotNull JetReferenceExpression expression) { + // do nothing + } - void reportMissingUnresolved(@NotNull JetReferenceExpression expression); + public abstract void reportElementWithErrorType(@NotNull JetReferenceExpression expression); - void reportUnresolvedWithTarget(@NotNull JetReferenceExpression expression, @NotNull String target); + public abstract void reportMissingUnresolved(@NotNull JetReferenceExpression expression); + + public abstract void reportUnresolvedWithTarget(@NotNull JetReferenceExpression expression, @NotNull String target); } public static void markDebugAnnotations( @@ -103,6 +107,8 @@ public class DebugInfoUtil { } } + debugInfoReporter.preProcessReference(expression); + String target = null; DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, expression); if (declarationDescriptor != null) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt index 5a57f60866d..5911af2b801 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt @@ -33,6 +33,8 @@ import kotlin.platform.platformStatic import org.jetbrains.jet.storage.StorageManager import org.jetbrains.jet.context.LazinessToken import javax.inject.Inject +import org.jetbrains.jet.lang.resolve.lazy.LazyEntity +import org.jetbrains.jet.lang.resolve.lazy.ForceResolveUtil public class TypeResolver( private val annotationResolver: AnnotationResolver, @@ -65,9 +67,14 @@ public class TypeResolver( if (!c.allowBareTypes && lazinessToken.isLazy()) { // Bare types can be allowed only inside expressions; lazy type resolution is only relevant for declarations - class LazyKotlinType : DelegatingType() { + class LazyKotlinType : DelegatingType(), LazyEntity { private val _delegate = storageManager.createLazyValue { doResolvePossiblyBareType(c, typeReference).getActualType() } override fun getDelegate() = _delegate() + + override fun forceResolveAllContents() { + ForceResolveUtil.forceResolveAllContents(getConstructor()) + getArguments().forEach { ForceResolveUtil.forceResolveAllContents(it.getType()) } + } } val lazyKotlinType = LazyKotlinType() diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ForceResolveUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ForceResolveUtil.java index 9522343b006..44e96d26667 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ForceResolveUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ForceResolveUtil.java @@ -19,8 +19,7 @@ package org.jetbrains.jet.lang.resolve.lazy; import com.intellij.openapi.diagnostic.Logger; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.CallableDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.Annotations; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -75,6 +74,16 @@ public class ForceResolveUtil { } else if (object instanceof CallableDescriptor) { CallableDescriptor callableDescriptor = (CallableDescriptor) object; + ReceiverParameterDescriptor parameter = callableDescriptor.getExtensionReceiverParameter(); + if (parameter != null) { + forceResolveAllContents(parameter.getType()); + } + for (ValueParameterDescriptor parameterDescriptor : callableDescriptor.getValueParameters()) { + forceResolveAllContents(parameterDescriptor); + } + for (TypeParameterDescriptor typeParameterDescriptor : callableDescriptor.getTypeParameters()) { + forceResolveAllContents(typeParameterDescriptor.getUpperBounds()); + } forceResolveAllContents(callableDescriptor.getReturnType()); } } 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 fe63c2e7cdc..c2db24492a1 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 @@ -190,8 +190,7 @@ public abstract class ElementResolver { TypeConstructor constructor = ((ClassDescriptor) descriptor).getTypeConstructor(); for (TypeParameterDescriptor parameterDescriptor : constructor.getParameters()) { - LazyEntity lazyEntity = (LazyEntity) parameterDescriptor; - lazyEntity.forceResolveAllContents(); + ForceResolveUtil.forceResolveAllContents(parameterDescriptor); } } @@ -268,10 +267,7 @@ public abstract class ElementResolver { private static void typeParameterAdditionalResolve(KotlinCodeAnalyzer analyzer, JetTypeParameter typeParameter) { DeclarationDescriptor descriptor = analyzer.resolveToDescriptor(typeParameter); - assert descriptor instanceof LazyEntity; - - LazyEntity parameterDescriptor = (LazyEntity) descriptor; - parameterDescriptor.forceResolveAllContents(); + ForceResolveUtil.forceResolveAllContents(descriptor); } private void delegationSpecifierAdditionalResolve( @@ -282,7 +278,7 @@ public abstract class ElementResolver { LazyClassDescriptor descriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject); // Activate resolving of supertypes - descriptor.getTypeConstructor().getSupertypes(); + ForceResolveUtil.forceResolveAllContents(descriptor.getTypeConstructor().getSupertypes()); BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file); bodyResolver.resolveDelegationSpecifierList(createEmptyContext(resolveSession), classOrObject, descriptor, @@ -306,6 +302,7 @@ public abstract class ElementResolver { }); BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file); PropertyDescriptor descriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(jetProperty); + ForceResolveUtil.forceResolveAllContents(descriptor); JetExpression propertyInitializer = jetProperty.getInitializer(); if (propertyInitializer != null) { @@ -332,6 +329,7 @@ public abstract class ElementResolver { ) { JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(namedFunction); FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction); + ForceResolveUtil.forceResolveAllContents(functionDescriptor); BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file); bodyResolver.resolveFunctionBody(createEmptyContext(resolveSession), trace, namedFunction, functionDescriptor, scope); diff --git a/idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractInsertImportOnPasteTest.java b/idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractInsertImportOnPasteTest.java index af358a5d35f..0260de79efc 100644 --- a/idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractInsertImportOnPasteTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractInsertImportOnPasteTest.java @@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase; import org.jetbrains.jet.plugin.PluginTestCaseBase; import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage; +import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; import java.io.File; import java.util.List; @@ -109,6 +110,11 @@ public abstract class AbstractInsertImportOnPasteTest extends JetLightCodeInsigh } } DebugInfoUtil.markDebugAnnotations(file, bindingContext, new DebugInfoUtil.DebugInfoReporter() { + @Override + public void preProcessReference(@NotNull JetReferenceExpression expression) { + AnalyzerFacadeWithCache.getContextForElement(expression); + } + @Override public void reportElementWithErrorType(@NotNull JetReferenceExpression expression) { //do nothing