Drop TypeLazinessToken and LazyResolveToken

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -19,19 +19,18 @@ package org.jetbrains.kotlin.frontend.java.di
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.builtins.JvmBuiltInsPackageFragmentProvider
-import org.jetbrains.kotlin.javac.components.JavacBasedClassFinder
-import org.jetbrains.kotlin.javac.components.StubJavaResolverCache
-import org.jetbrains.kotlin.javac.components.JavacBasedSourceElementFactory
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.*
-import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.javac.components.JavacBasedClassFinder
+import org.jetbrains.kotlin.javac.components.JavacBasedSourceElementFactory
+import org.jetbrains.kotlin.javac.components.StubJavaResolverCache
 import org.jetbrains.kotlin.load.java.InternalFlexibleTypeTransformer
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
 import org.jetbrains.kotlin.load.java.components.*
@@ -98,7 +97,6 @@ fun createContainerForLazyResolveWithJava(
         jvmTarget: JvmTarget,
         languageVersionSettings: LanguageVersionSettings,
         useBuiltInsProvider: Boolean,
-        useLazyResolve: Boolean,
         useJavac: Boolean = false
 ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatform) {
     configureModule(moduleContext, JvmPlatform, jvmTarget, bindingTrace)
@@ -116,10 +114,6 @@ fun createContainerForLazyResolveWithJava(
     }
 
     targetEnvironment.configure(this)
-
-    if (useLazyResolve) {
-        useImpl<LazyResolveToken>()
-    }
 }.apply {
     if (useJavac)
         get<JavacBasedClassFinder>().initialize(bindingTrace, get<KotlinCodeAnalyzer>())
@@ -142,7 +136,7 @@ fun createContainerForTopDownAnalyzerForJvm(
 ): ComponentProvider = createContainerForLazyResolveWithJava(
         moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, moduleClassResolver,
         CompilerEnvironment, lookupTracker, packagePartProvider, jvmTarget, languageVersionSettings,
-        useBuiltInsProvider = true, useLazyResolve = false, useJavac = useJavac
+        useBuiltInsProvider = true, useJavac = useJavac
 )
 
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt

@@ -97,8 +97,7 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
                 packagePartProvider,
                 jvmTarget,
                 languageVersionSettings,
-                useBuiltInsProvider = false, // TODO: load built-ins from module dependencies in IDE
-                useLazyResolve = true
+                useBuiltInsProvider = false // TODO: load built-ins from module dependencies in IDE
         )
 
         StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(container, moduleInfo) }

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/DefaultAnalyzerFacade.kt

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
-import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -144,7 +143,6 @@ object DefaultAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
         useInstance(metadataFinderFactory.create(moduleContentScope))
 
         targetEnvironment.configure(this)
-        useImpl<LazyResolveToken>()
     }
 
     override val targetPlatform: TargetPlatform

compiler/frontend/src/org/jetbrains/kotlin/context/context.kt

@@ -104,15 +104,3 @@ fun ContextForNewModule(
     val module = ModuleDescriptorImpl(moduleName, projectContext.storageManager, builtIns, multiTargetPlatform)
     return MutableModuleContextImpl(module, projectContext)
 }
-
-
-@Deprecated("Used temporarily while we are in transition from to lazy resolve")
-open class TypeLazinessToken {
-    @Deprecated("Used temporarily while we are in transition from to lazy resolve")
-    open fun isLazy(): Boolean = false
-}
-
-@Deprecated("Used temporarily while we are in transition from to lazy resolve") class LazyResolveToken : TypeLazinessToken() {
-    @Deprecated("Used temporarily while we are in transition from to lazy resolve")
-    override fun isLazy() = true
-}

compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
-import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -161,7 +160,6 @@ fun createContainerForLazyResolve(
     useImpl<CompilerDeserializationConfiguration>()
     targetEnvironment.configure(this)
 
-    useImpl<LazyResolveToken>()
     useImpl<ResolveSession>()
 }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolutionContext.java

@@ -24,24 +24,18 @@ public class TypeResolutionContext {
     public final BindingTrace trace;
     public final boolean checkBounds;
     public final boolean allowBareTypes;
-    public final boolean forceResolveLazyTypes;
     public final boolean isDebuggerContext;
     public final boolean abbreviated;
 
     public TypeResolutionContext(@NotNull LexicalScope scope, @NotNull BindingTrace trace, boolean checkBounds, boolean allowBareTypes, boolean isDebuggerContext) {
-        this(scope, trace, checkBounds, allowBareTypes, allowBareTypes, isDebuggerContext, false);
+        this(scope, trace, checkBounds, allowBareTypes, isDebuggerContext, false);
     }
 
-    public TypeResolutionContext(@NotNull LexicalScope scope, @NotNull BindingTrace trace, boolean checkBounds, boolean allowBareTypes, boolean isDebuggerContext, boolean abbreviated) {
-        this(scope, trace, checkBounds, allowBareTypes, allowBareTypes, isDebuggerContext, abbreviated);
-    }
-
-    private TypeResolutionContext(
+    public TypeResolutionContext(
             @NotNull LexicalScope scope,
             @NotNull BindingTrace trace,
             boolean checkBounds,
             boolean allowBareTypes,
-            boolean forceResolveLazyTypes,
             boolean isDebuggerContext,
             boolean abbreviated
     ) {
@@ -49,12 +43,12 @@ public class TypeResolutionContext {
         this.trace = trace;
         this.checkBounds = checkBounds;
         this.allowBareTypes = allowBareTypes;
-        this.forceResolveLazyTypes = forceResolveLazyTypes;
         this.isDebuggerContext = isDebuggerContext;
         this.abbreviated = abbreviated;
     }
 
+    @NotNull
     public TypeResolutionContext noBareTypes() {
-        return new TypeResolutionContext(scope, trace, checkBounds, false, forceResolveLazyTypes, isDebuggerContext, abbreviated);
+        return new TypeResolutionContext(scope, trace, checkBounds, false, isDebuggerContext, abbreviated);
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt

@@ -20,7 +20,6 @@ import com.intellij.util.SmartList
 import org.jetbrains.kotlin.builtins.createFunctionType
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.context.TypeLazinessToken
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
@@ -62,11 +61,9 @@ class TypeResolver(
         private val qualifiedExpressionResolver: QualifiedExpressionResolver,
         private val moduleDescriptor: ModuleDescriptor,
         private val typeTransformerForTests: TypeTransformerForTests,
-        private val lazinessToken: TypeLazinessToken,
         private val dynamicTypesSettings: DynamicTypesSettings,
         private val dynamicCallableDescriptors: DynamicCallableDescriptors,
         private val identifierChecker: IdentifierChecker,
-        private val wrappedTypeFactory: WrappedTypeFactory,
         private val platformToKotlinClassMap: PlatformToKotlinClassMap,
         private val languageVersionSettings: LanguageVersionSettings
 ) {
@@ -115,37 +112,16 @@ class TypeResolver(
             return type(debugType)
         }
 
-        if (!c.allowBareTypes && !c.forceResolveLazyTypes && lazinessToken.isLazy()) {
-            // Bare types can be allowed only inside expressions; lazy type resolution is only relevant for declarations
-
-            val lazyKotlinType = wrappedTypeFactory.createLazyWrappedType {
-                doResolvePossiblyBareType(c, typeReference).actualType
-            }
-            c.trace.record(resolvedTypeSlice, typeReference, lazyKotlinType)
-            return type(lazyKotlinType)
-        }
-
-        val type = doResolvePossiblyBareType(c, typeReference)
-        if (!type.isBare) {
-            c.trace.record(resolvedTypeSlice, typeReference, type.actualType)
-        }
-        return type
-    }
-
-    private fun doResolvePossiblyBareType(c: TypeResolutionContext, typeReference: KtTypeReference): PossiblyBareType {
-        val typeElement = typeReference.typeElement
-
         val annotations = resolveTypeAnnotations(c, typeReference)
-
-        val type = resolveTypeElement(c, annotations, typeReference.modifierList, typeElement)
+        val type = resolveTypeElement(c, annotations, typeReference.modifierList, typeReference.typeElement)
         c.trace.recordScope(c.scope, typeReference)
 
         if (!type.isBare) {
             for (argument in type.actualType.arguments) {
                 forceResolveTypeContents(argument.type)
             }
+            c.trace.record(resolvedTypeSlice, typeReference, type.actualType)
         }
-
         return type
     }
 

compiler/frontend/src/org/jetbrains/kotlin/types/WrappedTypeFactory.kt

@@ -20,7 +20,9 @@ import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.storage.StorageManager
 
 open class WrappedTypeFactory(private val storageManager: StorageManager) {
-    open fun createLazyWrappedType(computation: () -> KotlinType): KotlinType = LazyWrappedType(storageManager, computation)
-    open fun createDeferredType(trace: BindingTrace, computation: () -> KotlinType): KotlinType = DeferredType.create(storageManager, trace, computation)
-    open fun createRecursionIntolerantDeferredType(trace: BindingTrace, computation: () -> KotlinType): KotlinType = DeferredType.createRecursionIntolerant(storageManager, trace, computation)
-}
+    open fun createDeferredType(trace: BindingTrace, computation: () -> KotlinType): KotlinType =
+            DeferredType.create(storageManager, trace, computation)
+
+    open fun createRecursionIntolerantDeferredType(trace: BindingTrace, computation: () -> KotlinType): KotlinType =
+            DeferredType.createRecursionIntolerant(storageManager, trace, computation)
+}

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/lightClasses/IDELightClassContexts.kt

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
-import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
@@ -270,8 +269,6 @@ object IDELightClassContexts {
             useImpl<AdHocAnnotationResolver>()
 
             useInstance(object : WrappedTypeFactory(sm) {
-                override fun createLazyWrappedType(computation: () -> KotlinType): KotlinType = errorType()
-
                 override fun createDeferredType(trace: BindingTrace, computation: () -> KotlinType) = errorType()
 
                 override fun createRecursionIntolerantDeferredType(trace: BindingTrace, computation: () -> KotlinType) = errorType()
@@ -280,7 +277,6 @@ object IDELightClassContexts {
             })
 
             IdeaEnvironment.configure(this)
-            useImpl<LazyResolveToken>()
 
             useImpl<ResolveSession>()
         }

idea/testData/checker/TypeArgumentsNotAllowed.kt

@@ -2,6 +2,6 @@ package foo
 
 open class A<T>
 
-fun <T> f(<warning descr="[UNUSED_PARAMETER] Parameter 't' is never used">t</warning>: T<error descr="[TYPE_ARGUMENTS_NOT_ALLOWED] Type arguments are not allowed for type parameters"><<error descr="[DEBUG] Reference is not resolved to anything, but is not marked unresolved">T</error>></error>) {}
+fun <T> f(<warning descr="[UNUSED_PARAMETER] Parameter 't' is never used">t</warning>: T<error descr="[TYPE_ARGUMENTS_NOT_ALLOWED] Type arguments are not allowed for type parameters"><T></error>) {}
 
-fun <T> use(<warning descr="[UNUSED_PARAMETER] Parameter 'b' is never used">b</warning>: foo<error descr="[TYPE_ARGUMENTS_NOT_ALLOWED] Type arguments are not allowed here"><T></error>.A<T>) {}
+fun <T> use(<warning descr="[UNUSED_PARAMETER] Parameter 'b' is never used">b</warning>: foo<error descr="[TYPE_ARGUMENTS_NOT_ALLOWED] Type arguments are not allowed here"><T></error>.A<T>) {}