From bbe3b3cabe72abf78e69e4443c677ae1a2ca43c9 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Thu, 9 Feb 2017 15:33:53 +0300 Subject: [PATCH] WrappedType: introduce WrappedTypeFactory to encapsulate wrapped types creation --- .../kotlin/resolve/DescriptorResolver.java | 9 ++++--- .../jetbrains/kotlin/resolve/TypeResolver.kt | 5 ++-- .../VariableTypeAndInitializerResolver.kt | 13 ++++------ .../kotlin/resolve/lazy/LazyClassContext.kt | 2 ++ .../kotlin/resolve/lazy/ResolveSession.java | 13 ++++++++++ .../lazy/descriptors/LazyClassMemberScope.kt | 2 +- .../jetbrains/kotlin/types/DeferredType.java | 4 +-- .../kotlin/types/WrappedTypeFactory.kt | 26 +++++++++++++++++++ .../BasicExpressionTypingVisitor.java | 16 ++++++------ .../ExpressionTypingComponents.java | 7 +++++ .../expressions/LocalClassifierAnalyzer.kt | 11 +++++--- 11 files changed, 80 insertions(+), 28 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/types/WrappedTypeFactory.kt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index da86d027830..2c3d4bbfa47 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -85,6 +85,7 @@ public class DescriptorResolver { private final FunctionsTypingVisitor functionsTypingVisitor; private final DestructuringDeclarationResolver destructuringDeclarationResolver; private final ModifiersChecker modifiersChecker; + private final WrappedTypeFactory wrappedTypeFactory; private final SyntheticResolveExtension syntheticResolveExtension; public DescriptorResolver( @@ -100,6 +101,7 @@ public class DescriptorResolver { @NotNull FunctionsTypingVisitor functionsTypingVisitor, @NotNull DestructuringDeclarationResolver destructuringDeclarationResolver, @NotNull ModifiersChecker modifiersChecker, + @NotNull WrappedTypeFactory wrappedTypeFactory, @NotNull Project project ) { this.annotationResolver = annotationResolver; @@ -114,6 +116,7 @@ public class DescriptorResolver { this.functionsTypingVisitor = functionsTypingVisitor; this.destructuringDeclarationResolver = destructuringDeclarationResolver; this.modifiersChecker = modifiersChecker; + this.wrappedTypeFactory = wrappedTypeFactory; this.syntheticResolveExtension = SyntheticResolveExtension.Companion.getInstance(project); } @@ -928,7 +931,7 @@ public class DescriptorResolver { } - @Nullable + @NotNull /*package*/ static KotlinType transformAnonymousTypeIfNeeded( @NotNull DeclarationDescriptorWithVisibility descriptor, @NotNull KtDeclaration declaration, @@ -1104,14 +1107,14 @@ public class DescriptorResolver { } @NotNull - /*package*/ DeferredType inferReturnTypeFromExpressionBody( + /*package*/ KotlinType inferReturnTypeFromExpressionBody( @NotNull final BindingTrace trace, @NotNull final LexicalScope scope, @NotNull final DataFlowInfo dataFlowInfo, @NotNull final KtDeclarationWithBody function, @NotNull final FunctionDescriptor functionDescriptor ) { - return DeferredType.createRecursionIntolerant(storageManager, trace, new Function0() { + return wrappedTypeFactory.createRecursionIntolerantDeferredType(trace, new Function0() { @Override public KotlinType invoke() { PreliminaryDeclarationVisitor.Companion.createForDeclaration(function, trace); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt index ebd12116da1..f4789ff5273 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt @@ -51,7 +51,6 @@ import org.jetbrains.kotlin.resolve.scopes.utils.findFirstFromMeAndParent import org.jetbrains.kotlin.resolve.source.KotlinSourceElement import org.jetbrains.kotlin.resolve.source.toSourceElement import org.jetbrains.kotlin.storage.LockBasedStorageManager -import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.Variance.* import org.jetbrains.kotlin.types.typeUtil.containsTypeAliasParameters @@ -63,11 +62,11 @@ class TypeResolver( private val qualifiedExpressionResolver: QualifiedExpressionResolver, private val moduleDescriptor: ModuleDescriptor, private val typeTransformerForTests: TypeTransformerForTests, - private val storageManager: StorageManager, 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 ) { @@ -119,7 +118,7 @@ class TypeResolver( 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 = LazyWrappedType(storageManager) { + val lazyKotlinType = wrappedTypeFactory.createLazyWrappedType { doResolvePossiblyBareType(c, typeReference).actualType } c.trace.record(resolvedTypeSlice, typeReference, lazyKotlinType) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/VariableTypeAndInitializerResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/VariableTypeAndInitializerResolver.kt index b078ad29b01..9256129bb2e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/VariableTypeAndInitializerResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/VariableTypeAndInitializerResolver.kt @@ -28,10 +28,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator import org.jetbrains.kotlin.resolve.scopes.LexicalScope import org.jetbrains.kotlin.storage.StorageManager -import org.jetbrains.kotlin.types.DeferredType -import org.jetbrains.kotlin.types.ErrorUtils -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.TypeUtils +import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor @@ -40,7 +37,8 @@ class VariableTypeAndInitializerResolver( private val expressionTypingServices: ExpressionTypingServices, private val typeResolver: TypeResolver, private val constantExpressionEvaluator: ConstantExpressionEvaluator, - private val delegatedPropertyResolver: DelegatedPropertyResolver + private val delegatedPropertyResolver: DelegatedPropertyResolver, + private val wrappedTypeFactory: WrappedTypeFactory ) { companion object { @JvmField @@ -82,8 +80,7 @@ class VariableTypeAndInitializerResolver( variable.hasInitializer() -> when { !local -> - DeferredType.createRecursionIntolerant( - storageManager, + wrappedTypeFactory.createRecursionIntolerantDeferredType( trace ) { PreliminaryDeclarationVisitor.createForDeclaration(variable, trace) @@ -133,7 +130,7 @@ class VariableTypeAndInitializerResolver( scopeForInitializer: LexicalScope, dataFlowInfo: DataFlowInfo, trace: BindingTrace - ) = DeferredType.createRecursionIntolerant(storageManager, trace) { + ) = wrappedTypeFactory.createRecursionIntolerantDeferredType(trace) { val delegateExpression = property.delegateExpression!! val type = delegatedPropertyResolver.resolveDelegateExpression( delegateExpression, property, variableDescriptor, scopeForInitializer, trace, dataFlowInfo) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt index ffc15aaabaf..fb37ff382a0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory import org.jetbrains.kotlin.storage.StorageManager +import org.jetbrains.kotlin.types.WrappedTypeFactory interface LazyClassContext { val declarationScopeProvider: DeclarationScopeProvider @@ -41,4 +42,5 @@ interface LazyClassContext { val languageVersionSettings: LanguageVersionSettings val syntheticResolveExtension: SyntheticResolveExtension val delegationFilter: DelegationFilter + val wrappedTypeFactory: WrappedTypeFactory } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java index d59f7066e4a..40e318ff3b4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java @@ -47,6 +47,7 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor; import org.jetbrains.kotlin.resolve.scopes.LexicalScope; import org.jetbrains.kotlin.resolve.scopes.MemberScope; import org.jetbrains.kotlin.storage.*; +import org.jetbrains.kotlin.types.WrappedTypeFactory; import org.jetbrains.kotlin.utils.SmartList; import javax.inject.Inject; @@ -82,6 +83,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { private SupertypeLoopChecker supertypeLoopsResolver; private LanguageVersionSettings languageVersionSettings; private DelegationFilter delegationFilter; + private WrappedTypeFactory wrappedTypeFactory; private final SyntheticResolveExtension syntheticResolveExtension; @@ -141,6 +143,11 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { this.delegationFilter = delegationFilter; } + @Inject + public void setWrappedTypeFactory(WrappedTypeFactory wrappedTypeFactory) { + this.wrappedTypeFactory = wrappedTypeFactory; + } + // Only calls from injectors expected @Deprecated public ResolveSession( @@ -463,4 +470,10 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { public SyntheticResolveExtension getSyntheticResolveExtension() { return syntheticResolveExtension; } + + @NotNull + @Override + public WrappedTypeFactory getWrappedTypeFactory() { + return wrappedTypeFactory; + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt index 41c6c3310f9..308a31b0699 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt @@ -368,7 +368,7 @@ open class LazyClassMemberScope( } protected fun setDeferredReturnType(descriptor: ClassConstructorDescriptorImpl) { - descriptor.returnType = DeferredType.create(c.storageManager, trace, { thisDescriptor.defaultType }) + descriptor.returnType = c.wrappedTypeFactory.createDeferredType(trace, { thisDescriptor.defaultType }) } override fun recordLookup(name: Name, from: LookupLocation) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java b/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java index 57a88697613..13d5174d909 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java @@ -45,7 +45,7 @@ public class DeferredType extends WrappedType { }; @NotNull - public static DeferredType create( + /*package private*/ static DeferredType create( @NotNull StorageManager storageManager, @NotNull BindingTrace trace, @NotNull Function0 compute @@ -56,7 +56,7 @@ public class DeferredType extends WrappedType { } @NotNull - public static DeferredType createRecursionIntolerant( + /*package private*/ static DeferredType createRecursionIntolerant( @NotNull StorageManager storageManager, @NotNull BindingTrace trace, @NotNull Function0 compute diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/WrappedTypeFactory.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/WrappedTypeFactory.kt new file mode 100644 index 00000000000..4fdb2f666ca --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/WrappedTypeFactory.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2010-2017 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.kotlin.types + +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) +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index 36583c2988f..1326bddc957 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -731,14 +731,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { final ClassDescriptor descriptor ) { if (slice == CLASS && declaration == expression.getObjectDeclaration()) { - KotlinType defaultType = DeferredType.createRecursionIntolerant(components.globalContext.getStorageManager(), - context.trace, - new Function0() { - @Override - public KotlinType invoke() { - return descriptor.getDefaultType(); - } - }); + KotlinType defaultType = components.wrappedTypeFactory.createRecursionIntolerantDeferredType( + context.trace, + new Function0() { + @Override + public KotlinType invoke() { + return descriptor.getDefaultType(); + } + }); result[0] = defaultType; } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java index 5e64c3f5289..1b26644adbc 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java @@ -28,6 +28,7 @@ import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker; import org.jetbrains.kotlin.resolve.calls.checkers.RttiExpressionChecker; import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator; +import org.jetbrains.kotlin.types.WrappedTypeFactory; import javax.inject.Inject; @@ -60,6 +61,7 @@ public class ExpressionTypingComponents { /*package*/ OverloadChecker overloadChecker; /*package*/ LanguageVersionSettings languageVersionSettings; /*package*/ Iterable rttiExpressionCheckers; + /*package*/ WrappedTypeFactory wrappedTypeFactory; @Inject public void setGlobalContext(@NotNull GlobalContext globalContext) { @@ -200,4 +202,9 @@ public class ExpressionTypingComponents { public void setRttiExpressionCheckers(@NotNull Iterable rttiExpressionCheckers) { this.rttiExpressionCheckers = rttiExpressionCheckers; } + + @Inject + public void setWrappedTypeFactory(WrappedTypeFactory wrappedTypeFactory) { + this.wrappedTypeFactory = wrappedTypeFactory; + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt index 1760c563b5e..38aa306cfb0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt @@ -52,6 +52,7 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor import org.jetbrains.kotlin.resolve.scopes.LexicalScope import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope import org.jetbrains.kotlin.storage.StorageManager +import org.jetbrains.kotlin.types.WrappedTypeFactory class LocalClassifierAnalyzer( private val globalContext: GlobalContext, @@ -65,7 +66,8 @@ class LocalClassifierAnalyzer( private val supertypeLoopChecker: SupertypeLoopChecker, private val targetPlatformVersion: TargetPlatformVersion, private val languageVersionSettings: LanguageVersionSettings, - private val delegationFilter: DelegationFilter + private val delegationFilter: DelegationFilter, + private val wrappedTypeFactory: WrappedTypeFactory ) { fun processClassOrObject( scope: LexicalWritableScope?, @@ -98,7 +100,8 @@ class LocalClassifierAnalyzer( supertypeLoopChecker, languageVersionSettings, SyntheticResolveExtension.getInstance(project), - delegationFilter + delegationFilter, + wrappedTypeFactory ) ) @@ -124,7 +127,8 @@ class LocalClassDescriptorHolder( val supertypeLoopChecker: SupertypeLoopChecker, val languageVersionSettings: LanguageVersionSettings, val syntheticResolveExtension: SyntheticResolveExtension, - val delegationFilter: DelegationFilter + val delegationFilter: DelegationFilter, + val wrappedTypeFactory: WrappedTypeFactory ) { // We do not need to synchronize here, because this code is used strictly from one thread private var classDescriptor: ClassDescriptor? = null @@ -163,6 +167,7 @@ class LocalClassDescriptorHolder( override val languageVersionSettings = this@LocalClassDescriptorHolder.languageVersionSettings override val syntheticResolveExtension = this@LocalClassDescriptorHolder.syntheticResolveExtension override val delegationFilter: DelegationFilter = this@LocalClassDescriptorHolder.delegationFilter + override val wrappedTypeFactory: WrappedTypeFactory = this@LocalClassDescriptorHolder.wrappedTypeFactory }, containingDeclaration, classOrObject.nameAsSafeName,