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.ResolveSession
import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils
import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.FqName
import javax.inject.Inject
import kotlin.properties.Delegates import kotlin.properties.Delegates
import org.jetbrains.kotlin.name.tail import org.jetbrains.kotlin.name.tail
import org.jetbrains.kotlin.resolve.BindingContext.* import org.jetbrains.kotlin.resolve.BindingContext.*
import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.BindingTrace
import org.jetbrains.kotlin.resolve.BindingContextUtils import org.jetbrains.kotlin.resolve.BindingContextUtils
public class LazyResolveBasedCache : JavaResolverCache { public class LazyResolveBasedCache(private val resolveSession: ResolveSession) : JavaResolverCache {
private var resolveSession by Delegates.notNull<ResolveSession>()
private val trace: BindingTrace get() = resolveSession.getTrace() private val trace: BindingTrace get() = resolveSession.getTrace()
Inject
public fun setSession(resolveSession: ResolveSession) {
this.resolveSession = resolveSession
}
override fun getClassResolvedFromSource(fqName: FqName): ClassDescriptor? { override fun getClassResolvedFromSource(fqName: FqName): ClassDescriptor? {
return trace.get(FQNAME_TO_CLASS_DESCRIPTOR, fqName.toUnsafe()) ?: findInPackageFragments(fqName) 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.Slices
import org.jetbrains.kotlin.util.slicedMap.WritableSlice import org.jetbrains.kotlin.util.slicedMap.WritableSlice
import javax.inject.Inject public class TraceBasedErrorReporter(private val trace: BindingTrace) : ErrorReporter {
public class TraceBasedErrorReporter : ErrorReporter {
companion object { companion object {
private val LOG = Logger.getInstance(javaClass<TraceBasedErrorReporter>()) private val LOG = Logger.getInstance(javaClass<TraceBasedErrorReporter>())
@@ -43,24 +41,17 @@ public class TraceBasedErrorReporter : ErrorReporter {
public val classId: ClassId 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) { 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>) { 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 // 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) { override fun reportCannotInferVisibility(descriptor: CallableMemberDescriptor) {
OverrideResolver.createCannotInferVisibilityReporter(trace!!).invoke(descriptor) OverrideResolver.createCannotInferVisibilityReporter(trace).invoke(descriptor)
} }
override fun reportLoadingError(message: String, exception: Exception?) { 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.resolve.jvm.kotlinSignature.SignaturesPropagationData;
import org.jetbrains.kotlin.types.JetType; import org.jetbrains.kotlin.types.JetType;
import javax.inject.Inject;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
public class TraceBasedExternalSignatureResolver implements ExternalSignatureResolver { public class TraceBasedExternalSignatureResolver implements ExternalSignatureResolver {
private BindingTrace trace; @NotNull private final BindingTrace trace;
private ExternalAnnotationResolver externalAnnotationResolver; @NotNull private final ExternalAnnotationResolver externalAnnotationResolver;
private Project project; @NotNull private final Project project;
@Inject public TraceBasedExternalSignatureResolver(
public void setTrace(BindingTrace trace) { @NotNull ExternalAnnotationResolver externalAnnotationResolver,
this.trace = trace; @NotNull Project project,
} @NotNull BindingTrace trace
) {
@Inject
public void setExternalAnnotationResolver(ExternalAnnotationResolver externalAnnotationResolver) {
this.externalAnnotationResolver = externalAnnotationResolver; this.externalAnnotationResolver = externalAnnotationResolver;
}
@Inject
public void setProject(Project project) {
this.project = project; this.project = project;
this.trace = trace;
} }
@Override @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.annotations.Nullable;
import org.jetbrains.kotlin.resolve.ImportPath; import org.jetbrains.kotlin.resolve.ImportPath;
import javax.inject.Inject;
import java.util.Collection; import java.util.Collection;
import java.util.Map; import java.util.Map;
import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
public class JetImportsFactory { public class JetImportsFactory {
private Project project; @NotNull private final Project project;
private final Map<ImportPath, JetImportDirective> importsCache = Maps.newHashMap(); private final Map<ImportPath, JetImportDirective> importsCache = Maps.newHashMap();
@Inject public JetImportsFactory(@NotNull Project project) {
public void setProject(@NotNull Project project) {
importsCache.clear();
this.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; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
public class AnnotationResolver { 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; public AnnotationResolver(
private StorageManager storageManager; @NotNull CallResolver callResolver,
private TypeResolver typeResolver; @NotNull ConstantExpressionEvaluator constantExpressionEvaluator,
private ConstantExpressionEvaluator constantExpressionEvaluator; @NotNull StorageManager storageManager
) {
@Inject
public void setCallResolver(CallResolver callResolver) {
this.callResolver = callResolver; this.callResolver = callResolver;
} this.constantExpressionEvaluator = constantExpressionEvaluator;
@Inject
public void setStorageManager(StorageManager storageManager) {
this.storageManager = storageManager; this.storageManager = storageManager;
} }
// component dependency cycle
@Inject @Inject
public void setTypeResolver(TypeResolver typeResolver) { public void setTypeResolver(@NotNull TypeResolver typeResolver) {
this.typeResolver = typeResolver; this.typeResolver = typeResolver;
} }
@Inject
public void setConstantExpressionEvaluator(ConstantExpressionEvaluator constantExpressionEvaluator) {
this.constantExpressionEvaluator = constantExpressionEvaluator;
}
@NotNull @NotNull
public Annotations resolveAnnotationsWithoutArguments( public Annotations resolveAnnotationsWithoutArguments(
@NotNull JetScope scope, @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.ReenteringLazyValueComputationException;
import org.jetbrains.kotlin.util.slicedMap.WritableSlice; import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
import javax.inject.Inject;
import java.util.*; import java.util.*;
import static org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER; 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; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
public class BodyResolver { public class BodyResolver {
private ScriptBodyResolver scriptBodyResolverResolver; @NotNull private final ScriptBodyResolver scriptBodyResolverResolver;
private ExpressionTypingServices expressionTypingServices; @NotNull private final ExpressionTypingServices expressionTypingServices;
private CallResolver callResolver; @NotNull private final CallResolver callResolver;
private ObservableBindingTrace trace; @NotNull private final ObservableBindingTrace trace;
private ControlFlowAnalyzer controlFlowAnalyzer; @NotNull private final ControlFlowAnalyzer controlFlowAnalyzer;
private DeclarationsChecker declarationsChecker; @NotNull private final DeclarationsChecker declarationsChecker;
private AnnotationResolver annotationResolver; @NotNull private final AnnotationResolver annotationResolver;
private DelegatedPropertyResolver delegatedPropertyResolver; @NotNull private final DelegatedPropertyResolver delegatedPropertyResolver;
private FunctionAnalyzerExtension functionAnalyzerExtension; @NotNull private final FunctionAnalyzerExtension functionAnalyzerExtension;
private AdditionalCheckerProvider additionalCheckerProvider; @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
private ValueParameterResolver valueParameterResolver; @NotNull private final ValueParameterResolver valueParameterResolver;
private BodyResolveCache bodyResolveCache; @NotNull private final BodyResolveCache bodyResolveCache;
//<editor-fold desc="Injector Setters"> public BodyResolver(
@Inject @NotNull AdditionalCheckerProvider additionalCheckerProvider,
public void setScriptBodyResolverResolver(@NotNull ScriptBodyResolver scriptBodyResolverResolver) { @NotNull AnnotationResolver annotationResolver,
this.scriptBodyResolverResolver = scriptBodyResolverResolver; @NotNull BodyResolveCache bodyResolveCache,
} @NotNull CallResolver callResolver,
@NotNull ControlFlowAnalyzer controlFlowAnalyzer,
@Inject @NotNull DeclarationsChecker declarationsChecker,
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { @NotNull DelegatedPropertyResolver delegatedPropertyResolver,
this.expressionTypingServices = expressionTypingServices; @NotNull ExpressionTypingServices expressionTypingServices,
} @NotNull FunctionAnalyzerExtension functionAnalyzerExtension,
@NotNull ScriptBodyResolver scriptBodyResolverResolver,
@Inject @NotNull BindingTrace trace,
public void setCallResolver(@NotNull CallResolver callResolver) { @NotNull ValueParameterResolver valueParameterResolver
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) {
this.additionalCheckerProvider = additionalCheckerProvider; this.additionalCheckerProvider = additionalCheckerProvider;
} this.annotationResolver = annotationResolver;
this.bodyResolveCache = bodyResolveCache;
@Inject this.callResolver = callResolver;
public void setValueParameterResolver(ValueParameterResolver valueParameterResolver) { 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; this.valueParameterResolver = valueParameterResolver;
} }
@Inject
public void setBodyResolveCache(BodyResolveCache bodyResolveCache) {
this.bodyResolveCache = bodyResolveCache;
}
//</editor-fold>
private void resolveBehaviorDeclarationBodies(@NotNull BodiesResolveContext c) { private void resolveBehaviorDeclarationBodies(@NotNull BodiesResolveContext c) {
resolveDelegationSpecifierLists(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.psi.*;
import org.jetbrains.kotlin.types.JetType; import org.jetbrains.kotlin.types.JetType;
import javax.inject.Inject;
import java.util.Map; import java.util.Map;
import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
public class ControlFlowAnalyzer { public class ControlFlowAnalyzer {
private BindingTrace trace; @NotNull private final BindingTrace trace;
@Inject public ControlFlowAnalyzer(@NotNull BindingTrace trace) {
public void setTrace(BindingTrace trace) {
this.trace = 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.resolve.lazy.TopLevelDescriptorProvider
import org.jetbrains.kotlin.utils.* import org.jetbrains.kotlin.utils.*
import javax.inject.Inject
import java.util.HashSet import java.util.HashSet
import org.jetbrains.kotlin.diagnostics.Errors.REDECLARATION import org.jetbrains.kotlin.diagnostics.Errors.REDECLARATION
import kotlin.properties.Delegates import kotlin.properties.Delegates
public class DeclarationResolver { public class DeclarationResolver(private val annotationResolver: AnnotationResolver,
private var _annotationResolver: AnnotationResolver by Delegates.notNull() private val trace: BindingTrace) {
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 fun resolveAnnotationsOnFiles(c: TopDownAnalysisContext, scopeProvider: FileScopeProvider) { public fun resolveAnnotationsOnFiles(c: TopDownAnalysisContext, scopeProvider: FileScopeProvider) {
val filesToScope = c.getFiles().keysToMap { scopeProvider.getFileScope(it) } val filesToScope = c.getFiles().keysToMap { scopeProvider.getFileScope(it) }
for ((file, fileScope) in filesToScope) { for ((file, fileScope) in filesToScope) {
_annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getAnnotationEntries(), _trace) annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getAnnotationEntries(), trace)
_annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getDanglingAnnotations(), _trace) annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getDanglingAnnotations(), trace)
} }
} }
@@ -95,7 +83,7 @@ public class DeclarationResolver {
} }
} }
for ((first, second) in redeclarations) { 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 = val reportAt =
if (declarationOrPackageDirective is JetPackageDirective) declarationOrPackageDirective.getNameIdentifier() if (declarationOrPackageDirective is JetPackageDirective) declarationOrPackageDirective.getNameIdentifier()
else declarationOrPackageDirective 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.TypeProjection;
import org.jetbrains.kotlin.types.checker.JetTypeChecker; import org.jetbrains.kotlin.types.checker.JetTypeChecker;
import javax.inject.Inject;
import java.util.*; import java.util.*;
import static org.jetbrains.kotlin.diagnostics.Errors.*; 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; import static org.jetbrains.kotlin.resolve.DescriptorUtils.classCanHaveOpenMembers;
public class DeclarationsChecker { public class DeclarationsChecker {
private BindingTrace trace; @NotNull private final BindingTrace trace;
private ModifiersChecker modifiersChecker; @NotNull private final ModifiersChecker modifiersChecker;
private DescriptorResolver descriptorResolver; @NotNull private final DescriptorResolver descriptorResolver;
@Inject public DeclarationsChecker(
public void setTrace(@NotNull BindingTrace trace) { @NotNull DescriptorResolver descriptorResolver,
this.trace = trace; @NotNull ModifiersChecker modifiersChecker,
} @NotNull BindingTrace trace
) {
@Inject
public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) {
this.descriptorResolver = descriptorResolver; this.descriptorResolver = descriptorResolver;
}
@Inject
public void setModifiersChecker(@NotNull ModifiersChecker modifiersChecker) {
this.modifiersChecker = modifiersChecker; this.modifiersChecker = modifiersChecker;
this.trace = trace;
} }
public void process(@NotNull BodiesResolveContext bodiesResolveContext) { 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.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.util.slicedMap.WritableSlice; import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
import javax.inject.Inject;
import java.util.List; import java.util.List;
import static org.jetbrains.kotlin.diagnostics.Errors.*; 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"); public static final Name PROPERTY_DELEGATED_FUNCTION_NAME = Name.identifier("propertyDelegated");
private ExpressionTypingServices expressionTypingServices; @NotNull private final ExpressionTypingServices expressionTypingServices;
private CallResolver callResolver; @NotNull private final CallResolver callResolver;
private KotlinBuiltIns builtIns; @NotNull private final KotlinBuiltIns builtIns;
private AdditionalCheckerProvider additionalCheckerProvider; @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
@Inject public DelegatedPropertyResolver(
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { @NotNull AdditionalCheckerProvider additionalCheckerProvider,
this.expressionTypingServices = expressionTypingServices; @NotNull KotlinBuiltIns builtIns,
} @NotNull CallResolver callResolver,
@NotNull 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) {
this.additionalCheckerProvider = additionalCheckerProvider; this.additionalCheckerProvider = additionalCheckerProvider;
this.builtIns = builtIns;
this.callResolver = callResolver;
this.expressionTypingServices = expressionTypingServices;
} }
@Nullable @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.checker.JetTypeChecker;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import javax.inject.Inject;
import java.util.*; import java.util.*;
import static org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER; 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); MODIFIERS_ILLEGAL_ON_PARAMETERS.remove(JetTokens.VARARG_KEYWORD);
} }
private TypeResolver typeResolver; @NotNull private final TypeResolver typeResolver;
private AnnotationResolver annotationResolver; @NotNull private final AnnotationResolver annotationResolver;
private ExpressionTypingServices expressionTypingServices; @NotNull private final ExpressionTypingServices expressionTypingServices;
private DelegatedPropertyResolver delegatedPropertyResolver; @NotNull private final DelegatedPropertyResolver delegatedPropertyResolver;
private StorageManager storageManager; @NotNull private final StorageManager storageManager;
private KotlinBuiltIns builtIns; @NotNull private final KotlinBuiltIns builtIns;
@Inject public DescriptorResolver(
public void setTypeResolver(@NotNull TypeResolver typeResolver) { @NotNull AnnotationResolver annotationResolver,
this.typeResolver = typeResolver; @NotNull KotlinBuiltIns builtIns,
} @NotNull DelegatedPropertyResolver delegatedPropertyResolver,
@NotNull ExpressionTypingServices expressionTypingServices,
@Inject @NotNull StorageManager storageManager,
public void setAnnotationResolver(@NotNull AnnotationResolver annotationResolver) { @NotNull TypeResolver typeResolver
) {
this.annotationResolver = annotationResolver; 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.builtIns = builtIns;
this.delegatedPropertyResolver = delegatedPropertyResolver;
this.expressionTypingServices = expressionTypingServices;
this.storageManager = storageManager;
this.typeResolver = typeResolver;
} }
public List<JetType> resolveSupertypes( 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.InlineAnalyzerExtension;
import org.jetbrains.kotlin.resolve.inline.InlineUtil; import org.jetbrains.kotlin.resolve.inline.InlineUtil;
import javax.inject.Inject;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@@ -34,10 +33,9 @@ public class FunctionAnalyzerExtension {
void process(@NotNull FunctionDescriptor descriptor, @NotNull JetNamedFunction function, @NotNull BindingTrace trace); void process(@NotNull FunctionDescriptor descriptor, @NotNull JetNamedFunction function, @NotNull BindingTrace trace);
} }
private BindingTrace trace; @NotNull private final BindingTrace trace;
@Inject public FunctionAnalyzerExtension(@NotNull BindingTrace trace) {
public void setTrace(@NotNull BindingTrace trace) {
this.trace = 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.lazy.descriptors.LazyClassDescriptor
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker
import java.util.ArrayList 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 { 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>() val topLevelFqNames = HashMultimap.create<FqName, JetElement>()
@@ -127,8 +71,8 @@ public class LazyTopDownAnalyzer {
if (file.isScript()) { if (file.isScript()) {
val script = file.getScript() ?: throw AssertionError("getScript() is null for file: $file") val script = file.getScript() ?: throw AssertionError("getScript() is null for file: $file")
DescriptorResolver.registerFileInPackage(trace!!, file) DescriptorResolver.registerFileInPackage(trace, file)
c.getScripts().put(script, topLevelDescriptorProvider!!.getScriptDescriptor(script)) c.getScripts().put(script, topLevelDescriptorProvider.getScriptDescriptor(script))
} }
else { else {
val packageDirective = file.getPackageDirective() val packageDirective = file.getPackageDirective()
@@ -137,7 +81,7 @@ public class LazyTopDownAnalyzer {
c.addFile(file) c.addFile(file)
packageDirective!!.accept(this) packageDirective!!.accept(this)
DescriptorResolver.registerFileInPackage(trace!!, file) DescriptorResolver.registerFileInPackage(trace, file)
registerDeclarations(file.getDeclarations()) registerDeclarations(file.getDeclarations())
@@ -146,16 +90,16 @@ public class LazyTopDownAnalyzer {
} }
override fun visitPackageDirective(directive: JetPackageDirective) { override fun visitPackageDirective(directive: JetPackageDirective) {
DescriptorResolver.resolvePackageHeader(directive, moduleDescriptor!!, trace!!) DescriptorResolver.resolvePackageHeader(directive, moduleDescriptor, trace)
} }
override fun visitImportDirective(importDirective: JetImportDirective) { override fun visitImportDirective(importDirective: JetImportDirective) {
val fileScope = fileScopeProvider!!.getFileScope(importDirective.getContainingJetFile()) as LazyFileScope val fileScope = fileScopeProvider.getFileScope(importDirective.getContainingJetFile())
fileScope.forceResolveImport(importDirective) fileScope.forceResolveImport(importDirective)
} }
override fun visitClassOrObject(classOrObject: JetClassOrObject) { override fun visitClassOrObject(classOrObject: JetClassOrObject) {
val descriptor = lazyDeclarationResolver!!.getClassDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes val descriptor = lazyDeclarationResolver.getClassDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes
c.getDeclaredClasses().put(classOrObject, descriptor) c.getDeclaredClasses().put(classOrObject, descriptor)
registerDeclarations(classOrObject.getDeclarations()) registerDeclarations(classOrObject.getDeclarations())
@@ -169,16 +113,16 @@ public class LazyTopDownAnalyzer {
for (jetDeclaration in classOrObject.getDeclarations()) { for (jetDeclaration in classOrObject.getDeclarations()) {
if (jetDeclaration is JetObjectDeclaration && jetDeclaration.isCompanion()) { if (jetDeclaration is JetObjectDeclaration && jetDeclaration.isCompanion()) {
if (companionObjectAlreadyFound) { if (companionObjectAlreadyFound) {
trace!!.report(MANY_COMPANION_OBJECTS.on(jetDeclaration)) trace.report(MANY_COMPANION_OBJECTS.on(jetDeclaration))
} }
companionObjectAlreadyFound = true companionObjectAlreadyFound = true
} }
else if (jetDeclaration is JetSecondaryConstructor) { else if (jetDeclaration is JetSecondaryConstructor) {
if (DescriptorUtils.isSingletonOrAnonymousObject(classDescriptor)) { if (DescriptorUtils.isSingletonOrAnonymousObject(classDescriptor)) {
trace!!.report(CONSTRUCTOR_IN_OBJECT.on(jetDeclaration)) trace.report(CONSTRUCTOR_IN_OBJECT.on(jetDeclaration))
} }
else if (classDescriptor.getKind() == ClassKind.INTERFACE) { 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) { private fun registerPrimaryConstructorParameters(klass: JetClass) {
for (jetParameter in klass.getPrimaryConstructorParameters()) { for (jetParameter in klass.getPrimaryConstructorParameters()) {
if (jetParameter.hasValOrVar()) { 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) { 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) { override fun visitEnumEntry(enumEntry: JetEnumEntry) {
@@ -211,11 +155,11 @@ public class LazyTopDownAnalyzer {
override fun visitAnonymousInitializer(initializer: JetClassInitializer) { override fun visitAnonymousInitializer(initializer: JetClassInitializer) {
val classOrObject = PsiTreeUtil.getParentOfType<JetClassOrObject>(initializer, javaClass<JetClassOrObject>())!! 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) { 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) { override fun visitMultiDeclaration(multiDeclaration: JetMultiDeclaration) {
@@ -238,18 +182,18 @@ public class LazyTopDownAnalyzer {
resolveAllHeadersInClasses(c) resolveAllHeadersInClasses(c)
declarationResolver!!.checkRedeclarationsInPackages(topLevelDescriptorProvider!!, topLevelFqNames) declarationResolver.checkRedeclarationsInPackages(topLevelDescriptorProvider, topLevelFqNames)
declarationResolver!!.checkRedeclarations(c) 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 return c
} }
@@ -262,7 +206,7 @@ public class LazyTopDownAnalyzer {
private fun createPropertyDescriptors(c: TopDownAnalysisContext, topLevelFqNames: Multimap<FqName, JetElement>, properties: List<JetProperty>) { private fun createPropertyDescriptors(c: TopDownAnalysisContext, topLevelFqNames: Multimap<FqName, JetElement>, properties: List<JetProperty>) {
for (property in properties) { for (property in properties) {
val descriptor = lazyDeclarationResolver!!.resolveToDescriptor(property) as PropertyDescriptor val descriptor = lazyDeclarationResolver.resolveToDescriptor(property) as PropertyDescriptor
c.getProperties().put(property, descriptor) c.getProperties().put(property, descriptor)
ForceResolveUtil.forceResolveAllContents(descriptor.getAnnotations()) ForceResolveUtil.forceResolveAllContents(descriptor.getAnnotations())
@@ -272,7 +216,7 @@ public class LazyTopDownAnalyzer {
private fun createFunctionDescriptors(c: TopDownAnalysisContext, functions: List<JetNamedFunction>) { private fun createFunctionDescriptors(c: TopDownAnalysisContext, functions: List<JetNamedFunction>) {
for (function in functions) { for (function in functions) {
val simpleFunctionDescriptor = lazyDeclarationResolver!!.resolveToDescriptor(function) as SimpleFunctionDescriptor val simpleFunctionDescriptor = lazyDeclarationResolver.resolveToDescriptor(function) as SimpleFunctionDescriptor
c.getFunctions().put(function, simpleFunctionDescriptor) c.getFunctions().put(function, simpleFunctionDescriptor)
ForceResolveUtil.forceResolveAllContents(simpleFunctionDescriptor.getAnnotations()) ForceResolveUtil.forceResolveAllContents(simpleFunctionDescriptor.getAnnotations())
for (parameterDescriptor in simpleFunctionDescriptor.getValueParameters()) { 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.KotlinCodeAnalyzer;
import org.jetbrains.kotlin.resolve.lazy.LazyFileScope; import org.jetbrains.kotlin.resolve.lazy.LazyFileScope;
import javax.inject.Inject;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collection; import java.util.Collection;
import java.util.List; import java.util.List;
public class LazyTopDownAnalyzerForTopLevel { public class LazyTopDownAnalyzerForTopLevel {
private KotlinCodeAnalyzer resolveSession; @NotNull private final KotlinCodeAnalyzer codeAnalyzer;
private LazyTopDownAnalyzer lazyTopDownAnalyzer; @NotNull private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
@Inject public LazyTopDownAnalyzerForTopLevel(
public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) { @NotNull LazyTopDownAnalyzer lazyTopDownAnalyzer,
this.resolveSession = kotlinCodeAnalyzer; @NotNull KotlinCodeAnalyzer codeAnalyzer
} ) {
@Inject
public void setLazyTopDownAnalyzer(@NotNull LazyTopDownAnalyzer lazyTopDownAnalyzer) {
this.lazyTopDownAnalyzer = lazyTopDownAnalyzer; this.lazyTopDownAnalyzer = lazyTopDownAnalyzer;
this.codeAnalyzer = codeAnalyzer;
} }
@NotNull @NotNull
@@ -56,15 +53,15 @@ public class LazyTopDownAnalyzerForTopLevel {
) { ) {
PackageFragmentProvider provider; PackageFragmentProvider provider;
if (additionalProviders.isEmpty()) { if (additionalProviders.isEmpty()) {
provider = resolveSession.getPackageFragmentProvider(); provider = codeAnalyzer.getPackageFragmentProvider();
} }
else { else {
provider = new CompositePackageFragmentProvider(KotlinPackage.plus( provider = new CompositePackageFragmentProvider(KotlinPackage.plus(
Arrays.asList(resolveSession.getPackageFragmentProvider()), Arrays.asList(codeAnalyzer.getPackageFragmentProvider()),
additionalProviders)); additionalProviders));
} }
((ModuleDescriptorImpl) resolveSession.getModuleDescriptor()).initialize(provider); ((ModuleDescriptorImpl) codeAnalyzer.getModuleDescriptor()).initialize(provider);
return analyzeDeclarations(topDownAnalysisMode, files); return analyzeDeclarations(topDownAnalysisMode, files);
} }
@@ -76,7 +73,7 @@ public class LazyTopDownAnalyzerForTopLevel {
) { ) {
TopDownAnalysisContext c = lazyTopDownAnalyzer.analyzeDeclarations(topDownAnalysisMode, elements, DataFlowInfo.EMPTY); TopDownAnalysisContext c = lazyTopDownAnalyzer.analyzeDeclarations(topDownAnalysisMode, elements, DataFlowInfo.EMPTY);
resolveImportsInAllFiles(c, resolveSession); resolveImportsInAllFiles(c, codeAnalyzer);
return c; 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.JetObjectDeclaration;
import org.jetbrains.kotlin.psi.JetSecondaryConstructor; import org.jetbrains.kotlin.psi.JetSecondaryConstructor;
import javax.inject.Inject;
import java.util.Collection; import java.util.Collection;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
@@ -37,10 +36,9 @@ import java.util.Set;
import static org.jetbrains.kotlin.resolve.DescriptorUtils.getFqName; import static org.jetbrains.kotlin.resolve.DescriptorUtils.getFqName;
public class OverloadResolver { public class OverloadResolver {
private BindingTrace trace; @NotNull private final BindingTrace trace;
@Inject public OverloadResolver(@NotNull BindingTrace trace) {
public void setTrace(BindingTrace trace) {
this.trace = 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.types.checker.JetTypeChecker;
import org.jetbrains.kotlin.utils.HashSetUtil; import org.jetbrains.kotlin.utils.HashSetUtil;
import javax.inject.Inject;
import java.util.*; import java.util.*;
import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.*; import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.*;
@@ -53,15 +52,12 @@ import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.
public class OverrideResolver { public class OverrideResolver {
private BindingTrace trace; @NotNull private final BindingTrace trace;
@Inject public OverrideResolver(@NotNull BindingTrace trace) {
public void setTrace(BindingTrace trace) {
this.trace = trace; this.trace = trace;
} }
public void check(@NotNull TopDownAnalysisContext c) { public void check(@NotNull TopDownAnalysisContext c) {
checkVisibility(c); checkVisibility(c);
checkOverrides(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.scopes.receivers.ReceiverValue;
import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
import javax.inject.Inject;
import java.util.Collection; import java.util.Collection;
import java.util.Collections; import java.util.Collections;
import java.util.Set; import java.util.Set;
@@ -41,18 +40,10 @@ import java.util.Set;
import static org.jetbrains.kotlin.diagnostics.Errors.*; import static org.jetbrains.kotlin.diagnostics.Errors.*;
public class QualifiedExpressionResolver { public class QualifiedExpressionResolver {
private SymbolUsageValidator symbolUsageValidator; @NotNull private final SymbolUsageValidator symbolUsageValidator;
private final ImportDirectiveProcessor importDirectiveProcessor = new ImportDirectiveProcessor(this); @NotNull private final ImportDirectiveProcessor importDirectiveProcessor = new ImportDirectiveProcessor(this);
/** public QualifiedExpressionResolver(@NotNull SymbolUsageValidator symbolUsageValidator) {
* @deprecated Instance of this class should be obtained from the Injector
*/
@Deprecated
public QualifiedExpressionResolver() {
}
@Inject
public void setSymbolUsageValidator(@NotNull SymbolUsageValidator symbolUsageValidator) {
this.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.ExpressionTypingContext;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import javax.inject.Inject;
import java.util.Map; import java.util.Map;
import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; 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 // SCRIPT: resolve symbols in scripts
public class ScriptBodyResolver { public class ScriptBodyResolver {
private ExpressionTypingServices expressionTypingServices; @NotNull private final ExpressionTypingServices expressionTypingServices;
private AdditionalCheckerProvider additionalCheckerProvider; @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
@Inject public ScriptBodyResolver(
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { @NotNull AdditionalCheckerProvider additionalCheckerProvider,
this.expressionTypingServices = expressionTypingServices; @NotNull ExpressionTypingServices expressionTypingServices
} ) {
@Inject
public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) {
this.additionalCheckerProvider = additionalCheckerProvider; this.additionalCheckerProvider = additionalCheckerProvider;
this.expressionTypingServices = expressionTypingServices;
} }
public void resolveScriptBodies(@NotNull BodiesResolveContext c) { 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.JetTypeInfo;
import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage; import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage;
import javax.inject.Inject;
import java.util.Collections; import java.util.Collections;
import java.util.List; 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; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
public class ArgumentTypeResolver { public class ArgumentTypeResolver {
@NotNull private final TypeResolver typeResolver;
@NotNull private final ExpressionTypingServices expressionTypingServices;
@NotNull private final KotlinBuiltIns builtIns;
private TypeResolver typeResolver; public ArgumentTypeResolver(
private ExpressionTypingServices expressionTypingServices; @NotNull KotlinBuiltIns builtIns,
private KotlinBuiltIns builtIns; @NotNull ExpressionTypingServices expressionTypingServices,
@NotNull TypeResolver typeResolver
@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) {
this.builtIns = builtIns; this.builtIns = builtIns;
this.expressionTypingServices = expressionTypingServices;
this.typeResolver = typeResolver;
} }
public static boolean isSubtypeOfForArgumentType( 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; private ExpressionTypingServices expressionTypingServices;
// component dependency cycle
@Inject @Inject
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
this.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 kotlin.jvm.functions.Function0;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.lexer.JetTokens;
import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.psi.*;
import org.jetbrains.kotlin.resolve.*; import org.jetbrains.kotlin.resolve.*;
import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
@@ -78,52 +78,56 @@ public class CallResolver {
private ArgumentTypeResolver argumentTypeResolver; private ArgumentTypeResolver argumentTypeResolver;
private GenericCandidateResolver genericCandidateResolver; private GenericCandidateResolver genericCandidateResolver;
private CallCompleter callCompleter; private CallCompleter callCompleter;
private TaskPrioritizer taskPrioritizer; @NotNull private final TaskPrioritizer taskPrioritizer;
private AdditionalCheckerProvider additionalCheckerProvider; @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
private static final PerformanceCounter callResolvePerfCounter = PerformanceCounter.Companion.create("Call resolve", ExpressionTypingVisitorDispatcher.typeInfoPerfCounter); 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); 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 @Inject
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
this.expressionTypingServices = expressionTypingServices; this.expressionTypingServices = expressionTypingServices;
} }
// component dependency cycle
@Inject @Inject
public void setTypeResolver(@NotNull TypeResolver typeResolver) { public void setTypeResolver(@NotNull TypeResolver typeResolver) {
this.typeResolver = typeResolver; this.typeResolver = typeResolver;
} }
// component dependency cycle
@Inject @Inject
public void setCandidateResolver(@NotNull CandidateResolver candidateResolver) { public void setCandidateResolver(@NotNull CandidateResolver candidateResolver) {
this.candidateResolver = candidateResolver; this.candidateResolver = candidateResolver;
} }
// component dependency cycle
@Inject @Inject
public void setArgumentTypeResolver(@NotNull ArgumentTypeResolver argumentTypeResolver) { public void setArgumentTypeResolver(@NotNull ArgumentTypeResolver argumentTypeResolver) {
this.argumentTypeResolver = argumentTypeResolver; this.argumentTypeResolver = argumentTypeResolver;
} }
// component dependency cycle
@Inject @Inject
public void setGenericCandidateResolver(GenericCandidateResolver genericCandidateResolver) { public void setGenericCandidateResolver(GenericCandidateResolver genericCandidateResolver) {
this.genericCandidateResolver = genericCandidateResolver; this.genericCandidateResolver = genericCandidateResolver;
} }
// component dependency cycle
@Inject @Inject
public void setCallCompleter(@NotNull CallCompleter callCompleter) { public void setCallCompleter(@NotNull CallCompleter callCompleter) {
this.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 @NotNull
public OverloadResolutionResults<VariableDescriptor> resolveSimpleProperty(@NotNull BasicCallResolutionContext context) { public OverloadResolutionResults<VariableDescriptor> resolveSimpleProperty(@NotNull BasicCallResolutionContext context) {
JetExpression calleeExpression = context.call.getCalleeExpression(); 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 { public class LazyDeclarationResolver {
private final BindingTrace trace; @NotNull private final TopLevelDescriptorProvider topLevelDescriptorProvider;
@NotNull private final BindingTrace trace;
protected DeclarationScopeProvider scopeProvider; protected DeclarationScopeProvider scopeProvider;
private TopLevelDescriptorProvider topLevelDescriptorProvider;
// component dependency cycle
@Inject @Inject
public void setDeclarationScopeProvider(@NotNull DeclarationScopeProviderImpl scopeProvider) { public void setDeclarationScopeProvider(@NotNull DeclarationScopeProviderImpl scopeProvider) {
this.scopeProvider = scopeProvider; this.scopeProvider = scopeProvider;
} }
@Inject
public void setTopLevelDescriptorProvider(@NotNull TopLevelDescriptorProvider topLevelDescriptorProvider) {
this.topLevelDescriptorProvider = topLevelDescriptorProvider;
}
@Deprecated @Deprecated
public LazyDeclarationResolver( public LazyDeclarationResolver(
@NotNull GlobalContext globalContext, @NotNull GlobalContext globalContext,
@NotNull BindingTrace delegationTrace @NotNull BindingTrace delegationTrace,
@NotNull TopLevelDescriptorProvider topLevelDescriptorProvider
) { ) {
this.topLevelDescriptorProvider = topLevelDescriptorProvider;
LockBasedLazyResolveStorageManager lockBasedLazyResolveStorageManager = LockBasedLazyResolveStorageManager lockBasedLazyResolveStorageManager =
new LockBasedLazyResolveStorageManager(globalContext.getStorageManager()); 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.JetType;
import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage; import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage;
import javax.inject.Inject;
import java.util.Iterator; import java.util.Iterator;
import java.util.List; import java.util.List;
@@ -50,19 +49,15 @@ public class ExpressionTypingServices {
private final ExpressionTypingFacade expressionTypingFacade; private final ExpressionTypingFacade expressionTypingFacade;
private final ExpressionTypingComponents expressionTypingComponents; private final ExpressionTypingComponents expressionTypingComponents;
private StatementFilter statementFilter; @NotNull private final StatementFilter statementFilter;
@Inject public ExpressionTypingServices(@NotNull ExpressionTypingComponents components, @NotNull StatementFilter statementFilter) {
public void setStatementFilter(@NotNull StatementFilter statementFilter) {
this.statementFilter = statementFilter;
}
public ExpressionTypingServices(@NotNull ExpressionTypingComponents components) {
this.expressionTypingComponents = components; this.expressionTypingComponents = components;
this.statementFilter = statementFilter;
this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(components); this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(components);
} }
public StatementFilter getStatementFilter() { @NotNull public StatementFilter getStatementFilter() {
return statementFilter; 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.types.JetType;
import org.jetbrains.kotlin.util.slicedMap.WritableSlice; import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
import javax.inject.Inject;
import java.util.Collections; import java.util.Collections;
import static org.jetbrains.kotlin.diagnostics.Errors.*; import static org.jetbrains.kotlin.diagnostics.Errors.*;
@@ -41,22 +40,17 @@ import static org.jetbrains.kotlin.resolve.BindingContext.*;
public class ForLoopConventionsChecker { public class ForLoopConventionsChecker {
private KotlinBuiltIns builtIns; @NotNull private final KotlinBuiltIns builtIns;
private SymbolUsageValidator symbolUsageValidator; @NotNull private final SymbolUsageValidator symbolUsageValidator;
private FakeCallResolver fakeCallResolver; @NotNull private final FakeCallResolver fakeCallResolver;
@Inject public ForLoopConventionsChecker(
public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) { @NotNull KotlinBuiltIns builtIns,
@NotNull FakeCallResolver fakeCallResolver,
@NotNull SymbolUsageValidator symbolUsageValidator
) {
this.builtIns = builtIns; this.builtIns = builtIns;
}
@Inject
public void setFakeCallResolver(@NotNull FakeCallResolver fakeCallResolver) {
this.fakeCallResolver = fakeCallResolver; this.fakeCallResolver = fakeCallResolver;
}
@Inject
public void setSymbolUsageValidator(SymbolUsageValidator symbolUsageValidator) {
this.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.PsiElement
import com.intellij.psi.util.PsiTreeUtil import com.intellij.psi.util.PsiTreeUtil
import org.jetbrains.annotations.NotNull
import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.container.get
import org.jetbrains.kotlin.context.GlobalContext import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.context.withModule import org.jetbrains.kotlin.context.withModule
@@ -45,14 +46,14 @@ import org.jetbrains.kotlin.storage.StorageManager
import org.jetbrains.kotlin.types.DynamicTypesSettings import org.jetbrains.kotlin.types.DynamicTypesSettings
public class LocalClassifierAnalyzer( public class LocalClassifierAnalyzer(
val globalContext: GlobalContext, private val globalContext: GlobalContext,
val storageManager: StorageManager, private val storageManager: StorageManager,
val descriptorResolver: DescriptorResolver, private val descriptorResolver: DescriptorResolver,
val funcionDescriptorResolver: FunctionDescriptorResolver, private val funcionDescriptorResolver: FunctionDescriptorResolver,
val typeResolver: TypeResolver, private val typeResolver: TypeResolver,
val annotationResolver: AnnotationResolver, private val annotationResolver: AnnotationResolver,
val additionalCheckerProvider: AdditionalCheckerProvider, private val additionalCheckerProvider: AdditionalCheckerProvider,
val dynamicTypesSettings: DynamicTypesSettings private val dynamicTypesSettings: DynamicTypesSettings
) { ) {
fun processClassOrObject( fun processClassOrObject(
scope: WritableScope?, scope: WritableScope?,
@@ -151,8 +152,9 @@ class LocalClassDescriptorHolder(
class LocalLazyDeclarationResolver( class LocalLazyDeclarationResolver(
globalContext: GlobalContext, globalContext: GlobalContext,
trace: BindingTrace, trace: BindingTrace,
val localClassDescriptorManager: LocalClassDescriptorHolder private val localClassDescriptorManager: LocalClassDescriptorHolder,
) : LazyDeclarationResolver(globalContext, trace) { topLevelDescriptorProvider : TopLevelDescriptorProvider
) : LazyDeclarationResolver(globalContext, trace, topLevelDescriptorProvider) {
override fun getClassDescriptor(classOrObject: JetClassOrObject): ClassDescriptor { override fun getClassDescriptor(classOrObject: JetClassOrObject): ClassDescriptor {
if (localClassDescriptorManager.isMyClass(classOrObject)) { if (localClassDescriptorManager.isMyClass(classOrObject)) {
@@ -166,7 +168,7 @@ class LocalLazyDeclarationResolver(
class DeclarationScopeProviderForLocalClassifierAnalyzer( class DeclarationScopeProviderForLocalClassifierAnalyzer(
lazyDeclarationResolver: LazyDeclarationResolver, lazyDeclarationResolver: LazyDeclarationResolver,
fileScopeProvider: FileScopeProvider, fileScopeProvider: FileScopeProvider,
val localClassDescriptorManager: LocalClassDescriptorHolder private val localClassDescriptorManager: LocalClassDescriptorHolder
) : DeclarationScopeProviderImpl(lazyDeclarationResolver, fileScopeProvider) { ) : DeclarationScopeProviderImpl(lazyDeclarationResolver, fileScopeProvider) {
override fun getResolutionScopeForDeclaration(elementOfDeclaration: PsiElement): JetScope { override fun getResolutionScopeForDeclaration(elementOfDeclaration: PsiElement): JetScope {
if (localClassDescriptorManager.isMyClass(elementOfDeclaration)) { 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) return resolver!!.resolveClass(javaClass)
} }
// component dependency cycle
var resolver: JavaDescriptorResolver? = null var resolver: JavaDescriptorResolver? = null
@Inject set @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; this.errorReporter = errorReporter;
} }
// component dependency cycle
@Inject @Inject
public void setComponents(@NotNull DeserializationComponentsForJava context) { public void setComponents(@NotNull DeserializationComponentsForJava context) {
this.components = context.getComponents(); 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() protected var components: DeserializationComponents by Delegates.notNull()
// component dependency cycle
Inject Inject
public fun setDeserializationComponents(components: DeserializationComponents) { public fun setDeserializationComponents(components: DeserializationComponents) {
this.components = components 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 class LocalClassResolverImpl : LocalClassResolver {
public var components: DeserializationComponents by Delegates.notNull() public var components: DeserializationComponents by Delegates.notNull()
// component dependency cycle
Inject Inject
public fun setDeserializationComponents(components: DeserializationComponents) { public fun setDeserializationComponents(components: DeserializationComponents) {
this.components = components this.components = components