Additional/forced resolve for lazy types

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) {

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()

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.*;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 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());
         }
     }

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;
+            ForceResolveUtil.forceResolveAllContents(parameterDescriptor);
-            lazyEntity.forceResolveAllContents();
         }
     }
 
@@ -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;
+        ForceResolveUtil.forceResolveAllContents(descriptor);
-
-        LazyEntity parameterDescriptor = (LazyEntity) descriptor;
-        parameterDescriptor.forceResolveAllContents();
     }
 
     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);

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