diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/LazyResolveBasedCache.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/LazyResolveBasedCache.kt index 4fa140afd49..2ca858a52a8 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/LazyResolveBasedCache.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/LazyResolveBasedCache.kt @@ -22,23 +22,16 @@ import org.jetbrains.kotlin.load.java.structure.impl.* import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils import org.jetbrains.kotlin.name.FqName -import javax.inject.Inject import kotlin.properties.Delegates import org.jetbrains.kotlin.name.tail import org.jetbrains.kotlin.resolve.BindingContext.* import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.BindingContextUtils -public class LazyResolveBasedCache : JavaResolverCache { - private var resolveSession by Delegates.notNull() +public class LazyResolveBasedCache(private val resolveSession: ResolveSession) : JavaResolverCache { private val trace: BindingTrace get() = resolveSession.getTrace() - Inject - public fun setSession(resolveSession: ResolveSession) { - this.resolveSession = resolveSession - } - override fun getClassResolvedFromSource(fqName: FqName): ClassDescriptor? { return trace.get(FQNAME_TO_CLASS_DESCRIPTOR, fqName.toUnsafe()) ?: findInPackageFragments(fqName) } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt index 4325c5dacaa..1fe61137776 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt @@ -26,9 +26,7 @@ import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter import org.jetbrains.kotlin.util.slicedMap.Slices import org.jetbrains.kotlin.util.slicedMap.WritableSlice -import javax.inject.Inject - -public class TraceBasedErrorReporter : ErrorReporter { +public class TraceBasedErrorReporter(private val trace: BindingTrace) : ErrorReporter { companion object { private val LOG = Logger.getInstance(javaClass()) @@ -43,24 +41,17 @@ public class TraceBasedErrorReporter : ErrorReporter { public val classId: ClassId ) - private var trace: BindingTrace? = null - - Inject - public fun setTrace(trace: BindingTrace) { - this.trace = trace - } - override fun reportIncompatibleAbiVersion(classId: ClassId, filePath: String, actualVersion: Int) { - trace!!.record(ABI_VERSION_ERRORS, filePath, AbiVersionErrorData(actualVersion, classId)) + trace.record(ABI_VERSION_ERRORS, filePath, AbiVersionErrorData(actualVersion, classId)) } override fun reportIncompleteHierarchy(descriptor: ClassDescriptor, unresolvedSuperClasses: List) { // TODO: MutableList is a workaround for KT-5792 Covariant types in Kotlin translated to wildcard types in Java - trace!!.record(INCOMPLETE_HIERARCHY, descriptor, unresolvedSuperClasses as MutableList) + trace.record(INCOMPLETE_HIERARCHY, descriptor, unresolvedSuperClasses as MutableList) } override fun reportCannotInferVisibility(descriptor: CallableMemberDescriptor) { - OverrideResolver.createCannotInferVisibilityReporter(trace!!).invoke(descriptor) + OverrideResolver.createCannotInferVisibilityReporter(trace).invoke(descriptor) } override fun reportLoadingError(message: String, exception: Exception?) { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java index 9fa7cfa7d22..3cf5f75eb89 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java @@ -35,28 +35,22 @@ import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.AlternativeMethodSignatu import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.SignaturesPropagationData; import org.jetbrains.kotlin.types.JetType; -import javax.inject.Inject; import java.util.Collections; import java.util.List; public class TraceBasedExternalSignatureResolver implements ExternalSignatureResolver { - private BindingTrace trace; - private ExternalAnnotationResolver externalAnnotationResolver; - private Project project; + @NotNull private final BindingTrace trace; + @NotNull private final ExternalAnnotationResolver externalAnnotationResolver; + @NotNull private final Project project; - @Inject - public void setTrace(BindingTrace trace) { - this.trace = trace; - } - - @Inject - public void setExternalAnnotationResolver(ExternalAnnotationResolver externalAnnotationResolver) { + public TraceBasedExternalSignatureResolver( + @NotNull ExternalAnnotationResolver externalAnnotationResolver, + @NotNull Project project, + @NotNull BindingTrace trace + ) { this.externalAnnotationResolver = externalAnnotationResolver; - } - - @Inject - public void setProject(Project project) { this.project = project; + this.trace = trace; } @Override diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java index 0155486c900..5b3e7fcb28f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java @@ -24,20 +24,17 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.resolve.ImportPath; -import javax.inject.Inject; import java.util.Collection; import java.util.Map; import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; public class JetImportsFactory { - private Project project; + @NotNull private final Project project; private final Map importsCache = Maps.newHashMap(); - @Inject - public void setProject(@NotNull Project project) { - importsCache.clear(); + public JetImportsFactory(@NotNull Project project) { this.project = project; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java index e03f12eced9..779db10c475 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java @@ -51,32 +51,27 @@ import static org.jetbrains.kotlin.diagnostics.Errors.NOT_AN_ANNOTATION_CLASS; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; public class AnnotationResolver { + @NotNull private final CallResolver callResolver; + @NotNull private final StorageManager storageManager; + @NotNull private TypeResolver typeResolver; + @NotNull private final ConstantExpressionEvaluator constantExpressionEvaluator; - private CallResolver callResolver; - private StorageManager storageManager; - private TypeResolver typeResolver; - private ConstantExpressionEvaluator constantExpressionEvaluator; - - @Inject - public void setCallResolver(CallResolver callResolver) { + public AnnotationResolver( + @NotNull CallResolver callResolver, + @NotNull ConstantExpressionEvaluator constantExpressionEvaluator, + @NotNull StorageManager storageManager + ) { this.callResolver = callResolver; - } - - @Inject - public void setStorageManager(StorageManager storageManager) { + this.constantExpressionEvaluator = constantExpressionEvaluator; this.storageManager = storageManager; } + // component dependency cycle @Inject - public void setTypeResolver(TypeResolver typeResolver) { + public void setTypeResolver(@NotNull TypeResolver typeResolver) { this.typeResolver = typeResolver; } - @Inject - public void setConstantExpressionEvaluator(ConstantExpressionEvaluator constantExpressionEvaluator) { - this.constantExpressionEvaluator = constantExpressionEvaluator; - } - @NotNull public Annotations resolveAnnotationsWithoutArguments( @NotNull JetScope scope, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index 475dde783db..a8a8f85fac7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java @@ -45,7 +45,6 @@ import org.jetbrains.kotlin.util.Box; import org.jetbrains.kotlin.util.ReenteringLazyValueComputationException; import org.jetbrains.kotlin.util.slicedMap.WritableSlice; -import javax.inject.Inject; import java.util.*; import static org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER; @@ -54,81 +53,47 @@ import static org.jetbrains.kotlin.resolve.BindingContext.*; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; public class BodyResolver { - private ScriptBodyResolver scriptBodyResolverResolver; - private ExpressionTypingServices expressionTypingServices; - private CallResolver callResolver; - private ObservableBindingTrace trace; - private ControlFlowAnalyzer controlFlowAnalyzer; - private DeclarationsChecker declarationsChecker; - private AnnotationResolver annotationResolver; - private DelegatedPropertyResolver delegatedPropertyResolver; - private FunctionAnalyzerExtension functionAnalyzerExtension; - private AdditionalCheckerProvider additionalCheckerProvider; - private ValueParameterResolver valueParameterResolver; - private BodyResolveCache bodyResolveCache; + @NotNull private final ScriptBodyResolver scriptBodyResolverResolver; + @NotNull private final ExpressionTypingServices expressionTypingServices; + @NotNull private final CallResolver callResolver; + @NotNull private final ObservableBindingTrace trace; + @NotNull private final ControlFlowAnalyzer controlFlowAnalyzer; + @NotNull private final DeclarationsChecker declarationsChecker; + @NotNull private final AnnotationResolver annotationResolver; + @NotNull private final DelegatedPropertyResolver delegatedPropertyResolver; + @NotNull private final FunctionAnalyzerExtension functionAnalyzerExtension; + @NotNull private final AdditionalCheckerProvider additionalCheckerProvider; + @NotNull private final ValueParameterResolver valueParameterResolver; + @NotNull private final BodyResolveCache bodyResolveCache; - // - @Inject - public void setScriptBodyResolverResolver(@NotNull ScriptBodyResolver scriptBodyResolverResolver) { - this.scriptBodyResolverResolver = scriptBodyResolverResolver; - } - - @Inject - public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { - this.expressionTypingServices = expressionTypingServices; - } - - @Inject - public void setCallResolver(@NotNull CallResolver callResolver) { - this.callResolver = callResolver; - } - - @Inject - public void setTrace(@NotNull BindingTrace trace) { - this.trace = new ObservableBindingTrace(trace); - } - - @Inject - public void setControlFlowAnalyzer(@NotNull ControlFlowAnalyzer controlFlowAnalyzer) { - this.controlFlowAnalyzer = controlFlowAnalyzer; - } - - @Inject - public void setDeclarationsChecker(@NotNull DeclarationsChecker declarationsChecker) { - this.declarationsChecker = declarationsChecker; - } - - @Inject - public void setAnnotationResolver(@NotNull AnnotationResolver annotationResolver) { - this.annotationResolver = annotationResolver; - } - - @Inject - public void setDelegatedPropertyResolver(@NotNull DelegatedPropertyResolver delegatedPropertyResolver) { - this.delegatedPropertyResolver = delegatedPropertyResolver; - } - - @Inject - public void setFunctionAnalyzerExtension(@NotNull FunctionAnalyzerExtension functionAnalyzerExtension) { - this.functionAnalyzerExtension = functionAnalyzerExtension; - } - - @Inject - public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) { + public BodyResolver( + @NotNull AdditionalCheckerProvider additionalCheckerProvider, + @NotNull AnnotationResolver annotationResolver, + @NotNull BodyResolveCache bodyResolveCache, + @NotNull CallResolver callResolver, + @NotNull ControlFlowAnalyzer controlFlowAnalyzer, + @NotNull DeclarationsChecker declarationsChecker, + @NotNull DelegatedPropertyResolver delegatedPropertyResolver, + @NotNull ExpressionTypingServices expressionTypingServices, + @NotNull FunctionAnalyzerExtension functionAnalyzerExtension, + @NotNull ScriptBodyResolver scriptBodyResolverResolver, + @NotNull BindingTrace trace, + @NotNull ValueParameterResolver valueParameterResolver + ) { this.additionalCheckerProvider = additionalCheckerProvider; - } - - @Inject - public void setValueParameterResolver(ValueParameterResolver valueParameterResolver) { + this.annotationResolver = annotationResolver; + this.bodyResolveCache = bodyResolveCache; + this.callResolver = callResolver; + this.controlFlowAnalyzer = controlFlowAnalyzer; + this.declarationsChecker = declarationsChecker; + this.delegatedPropertyResolver = delegatedPropertyResolver; + this.expressionTypingServices = expressionTypingServices; + this.functionAnalyzerExtension = functionAnalyzerExtension; + this.scriptBodyResolverResolver = scriptBodyResolverResolver; + this.trace = new ObservableBindingTrace(trace); this.valueParameterResolver = valueParameterResolver; } - @Inject - public void setBodyResolveCache(BodyResolveCache bodyResolveCache) { - this.bodyResolveCache = bodyResolveCache; - } - // - private void resolveBehaviorDeclarationBodies(@NotNull BodiesResolveContext c) { resolveDelegationSpecifierLists(c); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java index a82abdbe6a5..1ae7671d04f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java @@ -26,16 +26,14 @@ import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.types.JetType; -import javax.inject.Inject; import java.util.Map; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; public class ControlFlowAnalyzer { - private BindingTrace trace; + @NotNull private final BindingTrace trace; - @Inject - public void setTrace(BindingTrace trace) { + public ControlFlowAnalyzer(@NotNull BindingTrace trace) { this.trace = trace; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt index b03e082fb3b..d0b94d254ba 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt @@ -30,31 +30,19 @@ import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider import org.jetbrains.kotlin.resolve.lazy.TopLevelDescriptorProvider import org.jetbrains.kotlin.utils.* -import javax.inject.Inject import java.util.HashSet import org.jetbrains.kotlin.diagnostics.Errors.REDECLARATION import kotlin.properties.Delegates -public class DeclarationResolver { - private var _annotationResolver: AnnotationResolver by Delegates.notNull() - private var _trace: BindingTrace by Delegates.notNull() - - Inject - public fun setAnnotationResolver(annotationResolver: AnnotationResolver) { - this._annotationResolver = annotationResolver - } - - Inject - public fun setTrace(trace: BindingTrace) { - this._trace = trace - } +public class DeclarationResolver(private val annotationResolver: AnnotationResolver, + private val trace: BindingTrace) { public fun resolveAnnotationsOnFiles(c: TopDownAnalysisContext, scopeProvider: FileScopeProvider) { val filesToScope = c.getFiles().keysToMap { scopeProvider.getFileScope(it) } for ((file, fileScope) in filesToScope) { - _annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getAnnotationEntries(), _trace) - _annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getDanglingAnnotations(), _trace) + annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getAnnotationEntries(), trace) + annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getDanglingAnnotations(), trace) } } @@ -95,7 +83,7 @@ public class DeclarationResolver { } } for ((first, second) in redeclarations) { - _trace.report(REDECLARATION.on(first, second.asString())) + trace.report(REDECLARATION.on(first, second.asString())) } } @@ -110,7 +98,7 @@ public class DeclarationResolver { val reportAt = if (declarationOrPackageDirective is JetPackageDirective) declarationOrPackageDirective.getNameIdentifier() else declarationOrPackageDirective - _trace.report(Errors.REDECLARATION.on(reportAt, fqName.shortName().asString())) + trace.report(Errors.REDECLARATION.on(reportAt, fqName.shortName().asString())) } } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java index b89e99b8bb5..18b9fa6b54f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java @@ -35,7 +35,6 @@ import org.jetbrains.kotlin.types.TypeConstructor; import org.jetbrains.kotlin.types.TypeProjection; import org.jetbrains.kotlin.types.checker.JetTypeChecker; -import javax.inject.Inject; import java.util.*; import static org.jetbrains.kotlin.diagnostics.Errors.*; @@ -45,23 +44,18 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.classCanHaveAbstractM import static org.jetbrains.kotlin.resolve.DescriptorUtils.classCanHaveOpenMembers; public class DeclarationsChecker { - private BindingTrace trace; - private ModifiersChecker modifiersChecker; - private DescriptorResolver descriptorResolver; + @NotNull private final BindingTrace trace; + @NotNull private final ModifiersChecker modifiersChecker; + @NotNull private final DescriptorResolver descriptorResolver; - @Inject - public void setTrace(@NotNull BindingTrace trace) { - this.trace = trace; - } - - @Inject - public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) { + public DeclarationsChecker( + @NotNull DescriptorResolver descriptorResolver, + @NotNull ModifiersChecker modifiersChecker, + @NotNull BindingTrace trace + ) { this.descriptorResolver = descriptorResolver; - } - - @Inject - public void setModifiersChecker(@NotNull ModifiersChecker modifiersChecker) { this.modifiersChecker = modifiersChecker; + this.trace = trace; } public void process(@NotNull BodiesResolveContext bodiesResolveContext) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java index 95365bbdf35..e33c5ad9155 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java @@ -42,7 +42,6 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext; import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; import org.jetbrains.kotlin.util.slicedMap.WritableSlice; -import javax.inject.Inject; import java.util.List; import static org.jetbrains.kotlin.diagnostics.Errors.*; @@ -58,29 +57,21 @@ public class DelegatedPropertyResolver { public static final Name PROPERTY_DELEGATED_FUNCTION_NAME = Name.identifier("propertyDelegated"); - private ExpressionTypingServices expressionTypingServices; - private CallResolver callResolver; - private KotlinBuiltIns builtIns; - private AdditionalCheckerProvider additionalCheckerProvider; + @NotNull private final ExpressionTypingServices expressionTypingServices; + @NotNull private final CallResolver callResolver; + @NotNull private final KotlinBuiltIns builtIns; + @NotNull private final AdditionalCheckerProvider additionalCheckerProvider; - @Inject - public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { - this.expressionTypingServices = expressionTypingServices; - } - - @Inject - public void setCallResolver(@NotNull CallResolver callResolver) { - this.callResolver = callResolver; - } - - @Inject - public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) { - this.builtIns = builtIns; - } - - @Inject - public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) { + public DelegatedPropertyResolver( + @NotNull AdditionalCheckerProvider additionalCheckerProvider, + @NotNull KotlinBuiltIns builtIns, + @NotNull CallResolver callResolver, + @NotNull ExpressionTypingServices expressionTypingServices + ) { this.additionalCheckerProvider = additionalCheckerProvider; + this.builtIns = builtIns; + this.callResolver = callResolver; + this.expressionTypingServices = expressionTypingServices; } @Nullable diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index 7266aab9ce9..f24215e3e6d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -50,7 +50,6 @@ import org.jetbrains.kotlin.types.*; import org.jetbrains.kotlin.types.checker.JetTypeChecker; import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; -import javax.inject.Inject; import java.util.*; import static org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER; @@ -72,41 +71,27 @@ public class DescriptorResolver { MODIFIERS_ILLEGAL_ON_PARAMETERS.remove(JetTokens.VARARG_KEYWORD); } - private TypeResolver typeResolver; - private AnnotationResolver annotationResolver; - private ExpressionTypingServices expressionTypingServices; - private DelegatedPropertyResolver delegatedPropertyResolver; - private StorageManager storageManager; - private KotlinBuiltIns builtIns; + @NotNull private final TypeResolver typeResolver; + @NotNull private final AnnotationResolver annotationResolver; + @NotNull private final ExpressionTypingServices expressionTypingServices; + @NotNull private final DelegatedPropertyResolver delegatedPropertyResolver; + @NotNull private final StorageManager storageManager; + @NotNull private final KotlinBuiltIns builtIns; - @Inject - public void setTypeResolver(@NotNull TypeResolver typeResolver) { - this.typeResolver = typeResolver; - } - - @Inject - public void setAnnotationResolver(@NotNull AnnotationResolver annotationResolver) { + public DescriptorResolver( + @NotNull AnnotationResolver annotationResolver, + @NotNull KotlinBuiltIns builtIns, + @NotNull DelegatedPropertyResolver delegatedPropertyResolver, + @NotNull ExpressionTypingServices expressionTypingServices, + @NotNull StorageManager storageManager, + @NotNull TypeResolver typeResolver + ) { this.annotationResolver = annotationResolver; - } - - @Inject - public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { - this.expressionTypingServices = expressionTypingServices; - } - - @Inject - public void setDelegatedPropertyResolver(@NotNull DelegatedPropertyResolver delegatedPropertyResolver) { - this.delegatedPropertyResolver = delegatedPropertyResolver; - } - - @Inject - public void setStorageManager(@NotNull StorageManager storageManager) { - this.storageManager = storageManager; - } - - @Inject - public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) { this.builtIns = builtIns; + this.delegatedPropertyResolver = delegatedPropertyResolver; + this.expressionTypingServices = expressionTypingServices; + this.storageManager = storageManager; + this.typeResolver = typeResolver; } public List resolveSupertypes( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java index 7249c7cad07..22b8b869d3e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.psi.JetNamedFunction; import org.jetbrains.kotlin.resolve.inline.InlineAnalyzerExtension; import org.jetbrains.kotlin.resolve.inline.InlineUtil; -import javax.inject.Inject; import java.util.Collections; import java.util.List; import java.util.Map; @@ -34,10 +33,9 @@ public class FunctionAnalyzerExtension { void process(@NotNull FunctionDescriptor descriptor, @NotNull JetNamedFunction function, @NotNull BindingTrace trace); } - private BindingTrace trace; + @NotNull private final BindingTrace trace; - @Inject - public void setTrace(@NotNull BindingTrace trace) { + public FunctionAnalyzerExtension(@NotNull BindingTrace trace) { this.trace = trace; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt index 01f0e39475e..75bc0790d0c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt @@ -32,78 +32,22 @@ import org.jetbrains.kotlin.resolve.lazy.* import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker import java.util.ArrayList -import javax.inject.Inject - -public class LazyTopDownAnalyzer { - private var trace: BindingTrace? = null - private var declarationResolver: DeclarationResolver? = null - private var overrideResolver: OverrideResolver? = null - private var overloadResolver: OverloadResolver? = null - private var varianceChecker: VarianceChecker? = null - private var moduleDescriptor: ModuleDescriptor? = null - private var lazyDeclarationResolver: LazyDeclarationResolver? = null - private var bodyResolver: BodyResolver? = null - private var topLevelDescriptorProvider: TopLevelDescriptorProvider? = null - private var fileScopeProvider: FileScopeProvider? = null - private var declarationScopeProvider: DeclarationScopeProvider? = null - - Inject - public fun setLazyDeclarationResolver(lazyDeclarationResolver: LazyDeclarationResolver) { - this.lazyDeclarationResolver = lazyDeclarationResolver - } - - Inject - public fun setTopLevelDescriptorProvider(topLevelDescriptorProvider: TopLevelDescriptorProvider) { - this.topLevelDescriptorProvider = topLevelDescriptorProvider - } - - Inject - public fun setFileScopeProvider(fileScopeProvider: FileScopeProvider) { - this.fileScopeProvider = fileScopeProvider - } - - Inject - public fun setDeclarationScopeProvider(declarationScopeProvider: DeclarationScopeProviderImpl) { - this.declarationScopeProvider = declarationScopeProvider - } - - Inject - public fun setTrace(trace: BindingTrace) { - this.trace = trace - } - - Inject - public fun setDeclarationResolver(declarationResolver: DeclarationResolver) { - this.declarationResolver = declarationResolver - } - - Inject - public fun setOverrideResolver(overrideResolver: OverrideResolver) { - this.overrideResolver = overrideResolver - } - - Inject - public fun setVarianceChecker(varianceChecker: VarianceChecker) { - this.varianceChecker = varianceChecker - } - - Inject - public fun setOverloadResolver(overloadResolver: OverloadResolver) { - this.overloadResolver = overloadResolver - } - - Inject - public fun setModuleDescriptor(moduleDescriptor: ModuleDescriptor) { - this.moduleDescriptor = moduleDescriptor - } - - Inject - public fun setBodyResolver(bodyResolver: BodyResolver) { - this.bodyResolver = bodyResolver - } +public class LazyTopDownAnalyzer( + private val trace: BindingTrace, + private val declarationResolver: DeclarationResolver, + private val overrideResolver: OverrideResolver, + private val overloadResolver: OverloadResolver, + private val varianceChecker: VarianceChecker, + private val moduleDescriptor: ModuleDescriptor, + private val lazyDeclarationResolver: LazyDeclarationResolver, + private val bodyResolver: BodyResolver, + private val topLevelDescriptorProvider: TopLevelDescriptorProvider, + private val fileScopeProvider: FileScopeProvider, + private val declarationScopeProvider: DeclarationScopeProvider +) { public fun analyzeDeclarations(topDownAnalysisMode: TopDownAnalysisMode, declarations: Collection, outerDataFlowInfo: DataFlowInfo): TopDownAnalysisContext { - val c = TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo, declarationScopeProvider!!) + val c = TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo, declarationScopeProvider) val topLevelFqNames = HashMultimap.create() @@ -127,8 +71,8 @@ public class LazyTopDownAnalyzer { if (file.isScript()) { val script = file.getScript() ?: throw AssertionError("getScript() is null for file: $file") - DescriptorResolver.registerFileInPackage(trace!!, file) - c.getScripts().put(script, topLevelDescriptorProvider!!.getScriptDescriptor(script)) + DescriptorResolver.registerFileInPackage(trace, file) + c.getScripts().put(script, topLevelDescriptorProvider.getScriptDescriptor(script)) } else { val packageDirective = file.getPackageDirective() @@ -137,7 +81,7 @@ public class LazyTopDownAnalyzer { c.addFile(file) packageDirective!!.accept(this) - DescriptorResolver.registerFileInPackage(trace!!, file) + DescriptorResolver.registerFileInPackage(trace, file) registerDeclarations(file.getDeclarations()) @@ -146,16 +90,16 @@ public class LazyTopDownAnalyzer { } override fun visitPackageDirective(directive: JetPackageDirective) { - DescriptorResolver.resolvePackageHeader(directive, moduleDescriptor!!, trace!!) + DescriptorResolver.resolvePackageHeader(directive, moduleDescriptor, trace) } override fun visitImportDirective(importDirective: JetImportDirective) { - val fileScope = fileScopeProvider!!.getFileScope(importDirective.getContainingJetFile()) as LazyFileScope + val fileScope = fileScopeProvider.getFileScope(importDirective.getContainingJetFile()) fileScope.forceResolveImport(importDirective) } override fun visitClassOrObject(classOrObject: JetClassOrObject) { - val descriptor = lazyDeclarationResolver!!.getClassDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes + val descriptor = lazyDeclarationResolver.getClassDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes c.getDeclaredClasses().put(classOrObject, descriptor) registerDeclarations(classOrObject.getDeclarations()) @@ -169,16 +113,16 @@ public class LazyTopDownAnalyzer { for (jetDeclaration in classOrObject.getDeclarations()) { if (jetDeclaration is JetObjectDeclaration && jetDeclaration.isCompanion()) { if (companionObjectAlreadyFound) { - trace!!.report(MANY_COMPANION_OBJECTS.on(jetDeclaration)) + trace.report(MANY_COMPANION_OBJECTS.on(jetDeclaration)) } companionObjectAlreadyFound = true } else if (jetDeclaration is JetSecondaryConstructor) { if (DescriptorUtils.isSingletonOrAnonymousObject(classDescriptor)) { - trace!!.report(CONSTRUCTOR_IN_OBJECT.on(jetDeclaration)) + trace.report(CONSTRUCTOR_IN_OBJECT.on(jetDeclaration)) } else if (classDescriptor.getKind() == ClassKind.INTERFACE) { - trace!!.report(CONSTRUCTOR_IN_TRAIT.on(jetDeclaration)) + trace.report(CONSTRUCTOR_IN_TRAIT.on(jetDeclaration)) } } } @@ -192,13 +136,13 @@ public class LazyTopDownAnalyzer { private fun registerPrimaryConstructorParameters(klass: JetClass) { for (jetParameter in klass.getPrimaryConstructorParameters()) { if (jetParameter.hasValOrVar()) { - c.getPrimaryConstructorParameterProperties().put(jetParameter, lazyDeclarationResolver!!.resolveToDescriptor(jetParameter) as PropertyDescriptor) + c.getPrimaryConstructorParameterProperties().put(jetParameter, lazyDeclarationResolver.resolveToDescriptor(jetParameter) as PropertyDescriptor) } } } override fun visitSecondaryConstructor(constructor: JetSecondaryConstructor) { - c.getSecondaryConstructors().put(constructor, lazyDeclarationResolver!!.resolveToDescriptor(constructor) as ConstructorDescriptor) + c.getSecondaryConstructors().put(constructor, lazyDeclarationResolver.resolveToDescriptor(constructor) as ConstructorDescriptor) } override fun visitEnumEntry(enumEntry: JetEnumEntry) { @@ -211,11 +155,11 @@ public class LazyTopDownAnalyzer { override fun visitAnonymousInitializer(initializer: JetClassInitializer) { val classOrObject = PsiTreeUtil.getParentOfType(initializer, javaClass())!! - c.getAnonymousInitializers().put(initializer, lazyDeclarationResolver!!.resolveToDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes) + c.getAnonymousInitializers().put(initializer, lazyDeclarationResolver.resolveToDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes) } override fun visitTypedef(typedef: JetTypedef) { - trace!!.report(UNSUPPORTED.on(typedef, "Typedefs are not supported")) + trace.report(UNSUPPORTED.on(typedef, "Typedefs are not supported")) } override fun visitMultiDeclaration(multiDeclaration: JetMultiDeclaration) { @@ -238,18 +182,18 @@ public class LazyTopDownAnalyzer { resolveAllHeadersInClasses(c) - declarationResolver!!.checkRedeclarationsInPackages(topLevelDescriptorProvider!!, topLevelFqNames) - declarationResolver!!.checkRedeclarations(c) + declarationResolver.checkRedeclarationsInPackages(topLevelDescriptorProvider, topLevelFqNames) + declarationResolver.checkRedeclarations(c) - overrideResolver!!.check(c) + overrideResolver.check(c) - varianceChecker!!.check(c) + varianceChecker.check(c) - declarationResolver!!.resolveAnnotationsOnFiles(c, fileScopeProvider!!) + declarationResolver.resolveAnnotationsOnFiles(c, fileScopeProvider) - overloadResolver!!.process(c) + overloadResolver.process(c) - bodyResolver!!.resolveBodies(c) + bodyResolver.resolveBodies(c) return c } @@ -262,7 +206,7 @@ public class LazyTopDownAnalyzer { private fun createPropertyDescriptors(c: TopDownAnalysisContext, topLevelFqNames: Multimap, properties: List) { for (property in properties) { - val descriptor = lazyDeclarationResolver!!.resolveToDescriptor(property) as PropertyDescriptor + val descriptor = lazyDeclarationResolver.resolveToDescriptor(property) as PropertyDescriptor c.getProperties().put(property, descriptor) ForceResolveUtil.forceResolveAllContents(descriptor.getAnnotations()) @@ -272,7 +216,7 @@ public class LazyTopDownAnalyzer { private fun createFunctionDescriptors(c: TopDownAnalysisContext, functions: List) { for (function in functions) { - val simpleFunctionDescriptor = lazyDeclarationResolver!!.resolveToDescriptor(function) as SimpleFunctionDescriptor + val simpleFunctionDescriptor = lazyDeclarationResolver.resolveToDescriptor(function) as SimpleFunctionDescriptor c.getFunctions().put(function, simpleFunctionDescriptor) ForceResolveUtil.forceResolveAllContents(simpleFunctionDescriptor.getAnnotations()) for (parameterDescriptor in simpleFunctionDescriptor.getValueParameters()) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java index 4f7a08dfd1b..34137d62142 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java @@ -28,24 +28,21 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer; import org.jetbrains.kotlin.resolve.lazy.LazyFileScope; -import javax.inject.Inject; import java.util.Arrays; import java.util.Collection; import java.util.List; public class LazyTopDownAnalyzerForTopLevel { - private KotlinCodeAnalyzer resolveSession; - private LazyTopDownAnalyzer lazyTopDownAnalyzer; + @NotNull private final KotlinCodeAnalyzer codeAnalyzer; + @NotNull private final LazyTopDownAnalyzer lazyTopDownAnalyzer; - @Inject - public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) { - this.resolveSession = kotlinCodeAnalyzer; - } - - @Inject - public void setLazyTopDownAnalyzer(@NotNull LazyTopDownAnalyzer lazyTopDownAnalyzer) { + public LazyTopDownAnalyzerForTopLevel( + @NotNull LazyTopDownAnalyzer lazyTopDownAnalyzer, + @NotNull KotlinCodeAnalyzer codeAnalyzer + ) { this.lazyTopDownAnalyzer = lazyTopDownAnalyzer; + this.codeAnalyzer = codeAnalyzer; } @NotNull @@ -56,15 +53,15 @@ public class LazyTopDownAnalyzerForTopLevel { ) { PackageFragmentProvider provider; if (additionalProviders.isEmpty()) { - provider = resolveSession.getPackageFragmentProvider(); + provider = codeAnalyzer.getPackageFragmentProvider(); } else { provider = new CompositePackageFragmentProvider(KotlinPackage.plus( - Arrays.asList(resolveSession.getPackageFragmentProvider()), + Arrays.asList(codeAnalyzer.getPackageFragmentProvider()), additionalProviders)); } - ((ModuleDescriptorImpl) resolveSession.getModuleDescriptor()).initialize(provider); + ((ModuleDescriptorImpl) codeAnalyzer.getModuleDescriptor()).initialize(provider); return analyzeDeclarations(topDownAnalysisMode, files); } @@ -76,7 +73,7 @@ public class LazyTopDownAnalyzerForTopLevel { ) { TopDownAnalysisContext c = lazyTopDownAnalyzer.analyzeDeclarations(topDownAnalysisMode, elements, DataFlowInfo.EMPTY); - resolveImportsInAllFiles(c, resolveSession); + resolveImportsInAllFiles(c, codeAnalyzer); return c; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java index cc651b6b51a..2e7bd8747cd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java @@ -29,7 +29,6 @@ import org.jetbrains.kotlin.psi.JetDeclaration; import org.jetbrains.kotlin.psi.JetObjectDeclaration; import org.jetbrains.kotlin.psi.JetSecondaryConstructor; -import javax.inject.Inject; import java.util.Collection; import java.util.Map; import java.util.Set; @@ -37,10 +36,9 @@ import java.util.Set; import static org.jetbrains.kotlin.resolve.DescriptorUtils.getFqName; public class OverloadResolver { - private BindingTrace trace; + @NotNull private final BindingTrace trace; - @Inject - public void setTrace(BindingTrace trace) { + public OverloadResolver(@NotNull BindingTrace trace) { this.trace = trace; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java index 2d70bbd2730..487ae768abb 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java @@ -42,7 +42,6 @@ import org.jetbrains.kotlin.types.*; import org.jetbrains.kotlin.types.checker.JetTypeChecker; import org.jetbrains.kotlin.utils.HashSetUtil; -import javax.inject.Inject; import java.util.*; import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.*; @@ -53,15 +52,12 @@ import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage. public class OverrideResolver { - private BindingTrace trace; + @NotNull private final BindingTrace trace; - @Inject - public void setTrace(BindingTrace trace) { + public OverrideResolver(@NotNull BindingTrace trace) { this.trace = trace; } - - public void check(@NotNull TopDownAnalysisContext c) { checkVisibility(c); checkOverrides(c); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java index e29fd460656..98f647407c3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java @@ -33,7 +33,6 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; -import javax.inject.Inject; import java.util.Collection; import java.util.Collections; import java.util.Set; @@ -41,18 +40,10 @@ import java.util.Set; import static org.jetbrains.kotlin.diagnostics.Errors.*; public class QualifiedExpressionResolver { - private SymbolUsageValidator symbolUsageValidator; - private final ImportDirectiveProcessor importDirectiveProcessor = new ImportDirectiveProcessor(this); + @NotNull private final SymbolUsageValidator symbolUsageValidator; + @NotNull private final ImportDirectiveProcessor importDirectiveProcessor = new ImportDirectiveProcessor(this); - /** - * @deprecated Instance of this class should be obtained from the Injector - */ - @Deprecated - public QualifiedExpressionResolver() { - } - - @Inject - public void setSymbolUsageValidator(@NotNull SymbolUsageValidator symbolUsageValidator) { + public QualifiedExpressionResolver(@NotNull SymbolUsageValidator symbolUsageValidator) { this.symbolUsageValidator = symbolUsageValidator; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java index a457e9d7e16..86e06a64666 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java @@ -27,7 +27,6 @@ import org.jetbrains.kotlin.types.expressions.CoercionStrategy; import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext; import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; -import javax.inject.Inject; import java.util.Map; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; @@ -36,17 +35,15 @@ import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; // SCRIPT: resolve symbols in scripts public class ScriptBodyResolver { - private ExpressionTypingServices expressionTypingServices; - private AdditionalCheckerProvider additionalCheckerProvider; + @NotNull private final ExpressionTypingServices expressionTypingServices; + @NotNull private final AdditionalCheckerProvider additionalCheckerProvider; - @Inject - public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { - this.expressionTypingServices = expressionTypingServices; - } - - @Inject - public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) { + public ScriptBodyResolver( + @NotNull AdditionalCheckerProvider additionalCheckerProvider, + @NotNull ExpressionTypingServices expressionTypingServices + ) { this.additionalCheckerProvider = additionalCheckerProvider; + this.expressionTypingServices = expressionTypingServices; } public void resolveScriptBodies(@NotNull BodiesResolveContext c) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java index 68c09c6bad1..862d20f2903 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java @@ -46,7 +46,6 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; import org.jetbrains.kotlin.types.expressions.JetTypeInfo; import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage; -import javax.inject.Inject; import java.util.Collections; import java.util.List; @@ -60,24 +59,18 @@ import static org.jetbrains.kotlin.types.TypeUtils.DONT_CARE; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; public class ArgumentTypeResolver { + @NotNull private final TypeResolver typeResolver; + @NotNull private final ExpressionTypingServices expressionTypingServices; + @NotNull private final KotlinBuiltIns builtIns; - private TypeResolver typeResolver; - private ExpressionTypingServices expressionTypingServices; - private KotlinBuiltIns builtIns; - - @Inject - public void setTypeResolver(@NotNull TypeResolver typeResolver) { - this.typeResolver = typeResolver; - } - - @Inject - public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { - this.expressionTypingServices = expressionTypingServices; - } - - @Inject - public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) { + public ArgumentTypeResolver( + @NotNull KotlinBuiltIns builtIns, + @NotNull ExpressionTypingServices expressionTypingServices, + @NotNull TypeResolver typeResolver + ) { this.builtIns = builtIns; + this.expressionTypingServices = expressionTypingServices; + this.typeResolver = typeResolver; } public static boolean isSubtypeOfForArgumentType( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java index 21447bd2e64..1cb3a6cdac8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java @@ -69,6 +69,7 @@ public class CallExpressionResolver { private ExpressionTypingServices expressionTypingServices; + // component dependency cycle @Inject public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { this.expressionTypingServices = expressionTypingServices; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java index c3b1edc1349..11ac9867533 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -23,10 +23,10 @@ import kotlin.Unit; import kotlin.jvm.functions.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.name.Name; +import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.*; import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; @@ -78,52 +78,56 @@ public class CallResolver { private ArgumentTypeResolver argumentTypeResolver; private GenericCandidateResolver genericCandidateResolver; private CallCompleter callCompleter; - private TaskPrioritizer taskPrioritizer; - private AdditionalCheckerProvider additionalCheckerProvider; + @NotNull private final TaskPrioritizer taskPrioritizer; + @NotNull private final AdditionalCheckerProvider additionalCheckerProvider; private static final PerformanceCounter callResolvePerfCounter = PerformanceCounter.Companion.create("Call resolve", ExpressionTypingVisitorDispatcher.typeInfoPerfCounter); private static final PerformanceCounter candidatePerfCounter = PerformanceCounter.Companion.create("Call resolve candidate analysis", true); + public CallResolver( + @NotNull TaskPrioritizer taskPrioritizer, + @NotNull AdditionalCheckerProvider additionalCheckerProvider + ) { + this.taskPrioritizer = taskPrioritizer; + this.additionalCheckerProvider = additionalCheckerProvider; + } + + // component dependency cycle @Inject public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { this.expressionTypingServices = expressionTypingServices; } + // component dependency cycle @Inject public void setTypeResolver(@NotNull TypeResolver typeResolver) { this.typeResolver = typeResolver; } + // component dependency cycle @Inject public void setCandidateResolver(@NotNull CandidateResolver candidateResolver) { this.candidateResolver = candidateResolver; } + // component dependency cycle @Inject public void setArgumentTypeResolver(@NotNull ArgumentTypeResolver argumentTypeResolver) { this.argumentTypeResolver = argumentTypeResolver; } + // component dependency cycle @Inject public void setGenericCandidateResolver(GenericCandidateResolver genericCandidateResolver) { this.genericCandidateResolver = genericCandidateResolver; } + // component dependency cycle @Inject public void setCallCompleter(@NotNull CallCompleter callCompleter) { this.callCompleter = callCompleter; } - @Inject - public void setTaskPrioritizer(@NotNull TaskPrioritizer taskPrioritizer) { - this.taskPrioritizer = taskPrioritizer; - } - - @Inject - public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) { - this.additionalCheckerProvider = additionalCheckerProvider; - } - @NotNull public OverloadResolutionResults resolveSimpleProperty(@NotNull BasicCallResolutionContext context) { JetExpression calleeExpression = context.call.getCalleeExpression(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java index 02ed9232825..cbe952096cb 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java @@ -38,26 +38,24 @@ import java.util.List; public class LazyDeclarationResolver { - private final BindingTrace trace; + @NotNull private final TopLevelDescriptorProvider topLevelDescriptorProvider; + @NotNull private final BindingTrace trace; protected DeclarationScopeProvider scopeProvider; - private TopLevelDescriptorProvider topLevelDescriptorProvider; + // component dependency cycle @Inject public void setDeclarationScopeProvider(@NotNull DeclarationScopeProviderImpl scopeProvider) { this.scopeProvider = scopeProvider; } - @Inject - public void setTopLevelDescriptorProvider(@NotNull TopLevelDescriptorProvider topLevelDescriptorProvider) { - this.topLevelDescriptorProvider = topLevelDescriptorProvider; - } - @Deprecated public LazyDeclarationResolver( @NotNull GlobalContext globalContext, - @NotNull BindingTrace delegationTrace + @NotNull BindingTrace delegationTrace, + @NotNull TopLevelDescriptorProvider topLevelDescriptorProvider ) { + this.topLevelDescriptorProvider = topLevelDescriptorProvider; LockBasedLazyResolveStorageManager lockBasedLazyResolveStorageManager = new LockBasedLazyResolveStorageManager(globalContext.getStorageManager()); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java index a9126f6a790..9867e0b7776 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java @@ -37,7 +37,6 @@ import org.jetbrains.kotlin.types.ErrorUtils; import org.jetbrains.kotlin.types.JetType; import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage; -import javax.inject.Inject; import java.util.Iterator; import java.util.List; @@ -50,19 +49,15 @@ public class ExpressionTypingServices { private final ExpressionTypingFacade expressionTypingFacade; private final ExpressionTypingComponents expressionTypingComponents; - private StatementFilter statementFilter; + @NotNull private final StatementFilter statementFilter; - @Inject - public void setStatementFilter(@NotNull StatementFilter statementFilter) { - this.statementFilter = statementFilter; - } - - public ExpressionTypingServices(@NotNull ExpressionTypingComponents components) { + public ExpressionTypingServices(@NotNull ExpressionTypingComponents components, @NotNull StatementFilter statementFilter) { this.expressionTypingComponents = components; + this.statementFilter = statementFilter; this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(components); } - public StatementFilter getStatementFilter() { + @NotNull public StatementFilter getStatementFilter() { return statementFilter; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java index d3e70365fda..b82965c9874 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java @@ -33,7 +33,6 @@ import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; import org.jetbrains.kotlin.types.JetType; import org.jetbrains.kotlin.util.slicedMap.WritableSlice; -import javax.inject.Inject; import java.util.Collections; import static org.jetbrains.kotlin.diagnostics.Errors.*; @@ -41,22 +40,17 @@ import static org.jetbrains.kotlin.resolve.BindingContext.*; public class ForLoopConventionsChecker { - private KotlinBuiltIns builtIns; - private SymbolUsageValidator symbolUsageValidator; - private FakeCallResolver fakeCallResolver; + @NotNull private final KotlinBuiltIns builtIns; + @NotNull private final SymbolUsageValidator symbolUsageValidator; + @NotNull private final FakeCallResolver fakeCallResolver; - @Inject - public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) { + public ForLoopConventionsChecker( + @NotNull KotlinBuiltIns builtIns, + @NotNull FakeCallResolver fakeCallResolver, + @NotNull SymbolUsageValidator symbolUsageValidator + ) { this.builtIns = builtIns; - } - - @Inject - public void setFakeCallResolver(@NotNull FakeCallResolver fakeCallResolver) { this.fakeCallResolver = fakeCallResolver; - } - - @Inject - public void setSymbolUsageValidator(SymbolUsageValidator symbolUsageValidator) { this.symbolUsageValidator = symbolUsageValidator; } 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 ac2cc72943e..7ec7c4cf7e2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.types.expressions import com.intellij.psi.PsiElement import com.intellij.psi.util.PsiTreeUtil +import org.jetbrains.annotations.NotNull import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.context.GlobalContext import org.jetbrains.kotlin.context.withModule @@ -45,14 +46,14 @@ import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.types.DynamicTypesSettings public class LocalClassifierAnalyzer( - val globalContext: GlobalContext, - val storageManager: StorageManager, - val descriptorResolver: DescriptorResolver, - val funcionDescriptorResolver: FunctionDescriptorResolver, - val typeResolver: TypeResolver, - val annotationResolver: AnnotationResolver, - val additionalCheckerProvider: AdditionalCheckerProvider, - val dynamicTypesSettings: DynamicTypesSettings + private val globalContext: GlobalContext, + private val storageManager: StorageManager, + private val descriptorResolver: DescriptorResolver, + private val funcionDescriptorResolver: FunctionDescriptorResolver, + private val typeResolver: TypeResolver, + private val annotationResolver: AnnotationResolver, + private val additionalCheckerProvider: AdditionalCheckerProvider, + private val dynamicTypesSettings: DynamicTypesSettings ) { fun processClassOrObject( scope: WritableScope?, @@ -151,8 +152,9 @@ class LocalClassDescriptorHolder( class LocalLazyDeclarationResolver( globalContext: GlobalContext, trace: BindingTrace, - val localClassDescriptorManager: LocalClassDescriptorHolder -) : LazyDeclarationResolver(globalContext, trace) { + private val localClassDescriptorManager: LocalClassDescriptorHolder, + topLevelDescriptorProvider : TopLevelDescriptorProvider +) : LazyDeclarationResolver(globalContext, trace, topLevelDescriptorProvider) { override fun getClassDescriptor(classOrObject: JetClassOrObject): ClassDescriptor { if (localClassDescriptorManager.isMyClass(classOrObject)) { @@ -166,7 +168,7 @@ class LocalLazyDeclarationResolver( class DeclarationScopeProviderForLocalClassifierAnalyzer( lazyDeclarationResolver: LazyDeclarationResolver, fileScopeProvider: FileScopeProvider, - val localClassDescriptorManager: LocalClassDescriptorHolder + private val localClassDescriptorManager: LocalClassDescriptorHolder ) : DeclarationScopeProviderImpl(lazyDeclarationResolver, fileScopeProvider) { override fun getResolutionScopeForDeclaration(elementOfDeclaration: PsiElement): JetScope { if (localClassDescriptorManager.isMyClass(elementOfDeclaration)) { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/ModuleClassResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/ModuleClassResolver.kt index cba15f0dfba..3d1653726aa 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/ModuleClassResolver.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/ModuleClassResolver.kt @@ -32,6 +32,7 @@ public class SingleModuleClassResolver() : ModuleClassResolver { return resolver!!.resolveClass(javaClass) } + // component dependency cycle var resolver: JavaDescriptorResolver? = null @Inject set } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java index 1738a9a12ea..29cfa72a0f9 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java @@ -45,6 +45,7 @@ public final class DeserializedDescriptorResolver { this.errorReporter = errorReporter; } + // component dependency cycle @Inject public void setComponents(@NotNull DeserializationComponentsForJava context) { this.components = context.getComponents(); diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializedPackageFragment.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializedPackageFragment.kt index 765947f6dfa..52f955cfcf6 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializedPackageFragment.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializedPackageFragment.kt @@ -44,6 +44,7 @@ public abstract class DeserializedPackageFragment( protected var components: DeserializationComponents by Delegates.notNull() + // component dependency cycle Inject public fun setDeserializationComponents(components: DeserializationComponents) { this.components = components diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/LocalClassResolverImpl.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/LocalClassResolverImpl.kt index bb6d55f5200..33b8f54d1ef 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/LocalClassResolverImpl.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/LocalClassResolverImpl.kt @@ -24,6 +24,7 @@ import kotlin.properties.Delegates public class LocalClassResolverImpl : LocalClassResolver { public var components: DeserializationComponents by Delegates.notNull() + // component dependency cycle Inject public fun setDeserializationComponents(components: DeserializationComponents) { this.components = components