azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace Injected properties with constructor parameters when it doesn't cause cycles

Browse Source
This commit is contained in:
Ilya Ryzhenkov
2015-07-17 21:59:23 +03:00
parent 76b9ac0f63
commit 84236992cb
29 changed files with 238 additions and 435 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/LazyResolveBasedCache.kt
+1 -8
View File
@@ -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<ResolveSession>()
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)
}
compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt
+4 -13
View File
@@ -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<TraceBasedErrorReporter>())
@@ -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<String>) {
// 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?) {
compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java
+9 -15
View File
@@ -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
compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java
+2 -5
View File
@@ -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<ImportPath, JetImportDirective> importsCache = Maps.newHashMap();
@Inject
public void setProject(@NotNull Project project) {
importsCache.clear();
public JetImportsFactory(@NotNull Project project) {
this.project = project;
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java
+12 -17
View File
@@ -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,
compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
+36 -71
View File
@@ -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;
//<editor-fold desc="Injector Setters">
@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;
}
//</editor-fold>
private void resolveBehaviorDeclarationBodies(@NotNull BodiesResolveContext c) {
resolveDelegationSpecifierLists(c);
compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java
+2 -4
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt
+6 -18
View File
@@ -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()))
}
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
+9 -15
View File
@@ -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) {
compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java
+13 -22
View File
@@ -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
compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
+18 -33
View File
@@ -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<JetType> resolveSupertypes(
compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java
+2 -4
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt
+36 -92
View File
@@ -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<PsiElement>, outerDataFlowInfo: DataFlowInfo): TopDownAnalysisContext {
val c = TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo, declarationScopeProvider!!)
val c = TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo, declarationScopeProvider)
val topLevelFqNames = HashMultimap.create<FqName, JetElement>()
@@ -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<JetClassOrObject>(initializer, javaClass<JetClassOrObject>())!!
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<FqName, JetElement>, properties: List<JetProperty>) {
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<JetNamedFunction>) {
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()) {
compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java
+11 -14
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java
+2 -4
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java
+2 -6
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java
+3 -12
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java
+7 -10
View File
@@ -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) {
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
+10 -17
View File
@@ -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(
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java
+1
View File
@@ -69,6 +69,7 @@ public class CallExpressionResolver {
private ExpressionTypingServices expressionTypingServices;
// component dependency cycle
@Inject
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
this.expressionTypingServices = expressionTypingServices;
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
+17 -13
View File
@@ -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<VariableDescriptor> resolveSimpleProperty(@NotNull BasicCallResolutionContext context) {
JetExpression calleeExpression = context.call.getCalleeExpression();
compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java
+6 -8
View File
@@ -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());
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java
+4 -9
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java
+8 -14
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
+13 -11
View File
@@ -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)) {
core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/ModuleClassResolver.kt
+1
View File
@@ -32,6 +32,7 @@ public class SingleModuleClassResolver() : ModuleClassResolver {
return resolver!!.resolveClass(javaClass)
}
// component dependency cycle
var resolver: JavaDescriptorResolver? = null
@Inject set
}
core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java
+1
View File
@@ -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();
core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializedPackageFragment.kt
+1
View File
@@ -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
core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/LocalClassResolverImpl.kt
+1
View File
@@ -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