diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java index 98c4d2e114e..ab87fabdffe 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -170,8 +170,8 @@ public class InjectorForLazyResolveWithJava { this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.typeResolver = new TypeResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -252,11 +252,6 @@ public class InjectorForLazyResolveWithJava { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); - typeResolver.setAnnotationResolver(annotationResolver); - typeResolver.setFlexibleTypeCapabilitiesProvider(javaFlexibleTypeCapabilitiesProvider); - typeResolver.setModuleDescriptor(module); - typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); - candidateResolver.setArgumentTypeResolver(argumentTypeResolver); jetImportsFactory.setProject(project); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index d84032bb26f..8348091e53f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -195,8 +195,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.typeResolver = new TypeResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), javaFlexibleTypeCapabilitiesProvider); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -305,11 +305,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); - typeResolver.setAnnotationResolver(annotationResolver); - typeResolver.setFlexibleTypeCapabilitiesProvider(javaFlexibleTypeCapabilitiesProvider); - typeResolver.setModuleDescriptor(moduleDescriptor); - typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); - candidateResolver.setArgumentTypeResolver(argumentTypeResolver); controlFlowAnalyzer.setTrace(bindingTrace); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java index 69761524c4d..cdae48f6db7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java @@ -37,8 +37,8 @@ import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; @@ -75,8 +75,8 @@ public class InjectorForBodyResolve { private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; - private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final QualifiedExpressionResolver qualifiedExpressionResolver; + private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final CallResolverExtensionProvider callResolverExtensionProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -113,9 +113,9 @@ public class InjectorForBodyResolve { this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.typeResolver = new TypeResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -181,11 +181,6 @@ public class InjectorForBodyResolve { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); - typeResolver.setAnnotationResolver(annotationResolver); - typeResolver.setFlexibleTypeCapabilitiesProvider(flexibleTypeCapabilitiesProvider); - typeResolver.setModuleDescriptor(moduleDescriptor); - typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); - candidateResolver.setArgumentTypeResolver(argumentTypeResolver); controlFlowAnalyzer.setTrace(bindingTrace); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 54860f07a43..b5337b44dcd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -38,8 +38,8 @@ import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; @@ -75,8 +75,8 @@ public class InjectorForLazyResolve { private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; - private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final QualifiedExpressionResolver qualifiedExpressionResolver; + private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final CallResolverExtensionProvider callResolverExtensionProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -113,9 +113,9 @@ public class InjectorForLazyResolve { this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.typeResolver = new TypeResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -177,11 +177,6 @@ public class InjectorForLazyResolve { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); - typeResolver.setAnnotationResolver(annotationResolver); - typeResolver.setFlexibleTypeCapabilitiesProvider(flexibleTypeCapabilitiesProvider); - typeResolver.setModuleDescriptor(moduleDescriptor); - typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); - candidateResolver.setArgumentTypeResolver(argumentTypeResolver); jetImportsFactory.setProject(project); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java index eec3c63ffa9..743dad42466 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java @@ -27,8 +27,8 @@ import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; @@ -58,8 +58,8 @@ public class InjectorForMacros { private final AdditionalCheckerProvider additionalCheckerProvider; private final AnnotationResolver annotationResolver; private final TypeResolver typeResolver; - private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final QualifiedExpressionResolver qualifiedExpressionResolver; + private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final CallExpressionResolver callExpressionResolver; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; @@ -86,9 +86,9 @@ public class InjectorForMacros { this.storageManager = globalContext.getStorageManager(); this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty.INSTANCE$; this.annotationResolver = new AnnotationResolver(); - this.typeResolver = new TypeResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider); this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); @@ -129,11 +129,6 @@ public class InjectorForMacros { annotationResolver.setStorageManager(storageManager); annotationResolver.setTypeResolver(typeResolver); - typeResolver.setAnnotationResolver(annotationResolver); - typeResolver.setFlexibleTypeCapabilitiesProvider(flexibleTypeCapabilitiesProvider); - typeResolver.setModuleDescriptor(moduleDescriptor); - typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 69aa01d2258..1a85b53456b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -40,8 +40,8 @@ import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; @@ -88,8 +88,8 @@ public class InjectorForTopDownAnalyzerBasic { private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; - private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final QualifiedExpressionResolver qualifiedExpressionResolver; + private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final CallResolverExtensionProvider callResolverExtensionProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -136,9 +136,9 @@ public class InjectorForTopDownAnalyzerBasic { this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.typeResolver = new TypeResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), flexibleTypeCapabilitiesProvider); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -230,11 +230,6 @@ public class InjectorForTopDownAnalyzerBasic { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); - typeResolver.setAnnotationResolver(annotationResolver); - typeResolver.setFlexibleTypeCapabilitiesProvider(flexibleTypeCapabilitiesProvider); - typeResolver.setModuleDescriptor(moduleDescriptor); - typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); - candidateResolver.setArgumentTypeResolver(argumentTypeResolver); controlFlowAnalyzer.setTrace(bindingTrace); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java deleted file mode 100644 index ab7047b0982..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ /dev/null @@ -1,347 +0,0 @@ -/* - * Copyright 2010-2013 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.lang.resolve; - -import kotlin.Function0; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter; -import org.jetbrains.jet.lang.types.*; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.storage.LockBasedStorageManager; - -import javax.inject.Inject; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -import static org.jetbrains.jet.lang.diagnostics.Errors.*; -import static org.jetbrains.jet.lang.resolve.PossiblyBareType.type; -import static org.jetbrains.jet.lang.types.Variance.*; - -public class TypeResolver { - - public static class FlexibleTypeCapabilitiesProvider { - public FlexibleTypeCapabilities getCapabilities() { - return FlexibleTypeCapabilities.NONE.INSTANCE$; - } - } - - private AnnotationResolver annotationResolver; - private QualifiedExpressionResolver qualifiedExpressionResolver; - private ModuleDescriptor moduleDescriptor; - private FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; - - @Inject - public void setAnnotationResolver(AnnotationResolver annotationResolver) { - this.annotationResolver = annotationResolver; - } - - @Inject - public void setQualifiedExpressionResolver(QualifiedExpressionResolver qualifiedExpressionResolver) { - this.qualifiedExpressionResolver = qualifiedExpressionResolver; - } - - @Inject - public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) { - this.moduleDescriptor = moduleDescriptor; - } - - - @Inject - public void setFlexibleTypeCapabilitiesProvider(@NotNull FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider) { - this.flexibleTypeCapabilitiesProvider = flexibleTypeCapabilitiesProvider; - } - - @NotNull - public JetType resolveType(@NotNull JetScope scope, @NotNull JetTypeReference typeReference, BindingTrace trace, boolean checkBounds) { - // bare types are not allowed - return resolveType(new TypeResolutionContext(scope, trace, checkBounds, false), typeReference); - } - - @NotNull - public JetType resolveType(@NotNull TypeResolutionContext c, @NotNull JetTypeReference typeReference) { - assert !c.allowBareTypes : "Use resolvePossiblyBareType() when bare types are allowed"; - return resolvePossiblyBareType(c, typeReference).getActualType(); - } - - @NotNull - public PossiblyBareType resolvePossiblyBareType(@NotNull TypeResolutionContext c, @NotNull JetTypeReference typeReference) { - JetType cachedType = c.trace.getBindingContext().get(BindingContext.TYPE, typeReference); - if (cachedType != null) return type(cachedType); - - Annotations annotations = annotationResolver.resolveAnnotationsWithArguments(c.scope, typeReference.getAnnotations(), c.trace); - - JetTypeElement typeElement = typeReference.getTypeElement(); - PossiblyBareType type = resolveTypeElement(c, annotations, typeElement); - if (!type.isBare()) { - c.trace.record(BindingContext.TYPE, typeReference, type.getActualType()); - } - c.trace.record(BindingContext.TYPE_RESOLUTION_SCOPE, typeReference, c.scope); - - return type; - } - - @NotNull - private PossiblyBareType resolveTypeElement( - final TypeResolutionContext c, - final Annotations annotations, - JetTypeElement typeElement - ) { - - final PossiblyBareType[] result = new PossiblyBareType[1]; - if (typeElement != null) { - typeElement.accept(new JetVisitorVoid() { - @Override - public void visitUserType(@NotNull JetUserType type) { - JetSimpleNameExpression referenceExpression = type.getReferenceExpression(); - String referencedName = type.getReferencedName(); - if (referenceExpression == null || referencedName == null) { - return; - } - - ClassifierDescriptor classifierDescriptor = resolveClass(c.scope, type, c.trace); - if (classifierDescriptor == null) { - resolveTypeProjections(c, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments()); - return; - } - - c.trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor); - - if (classifierDescriptor instanceof TypeParameterDescriptor) { - TypeParameterDescriptor typeParameterDescriptor = (TypeParameterDescriptor) classifierDescriptor; - - JetScope scopeForTypeParameter = getScopeForTypeParameter(c, typeParameterDescriptor); - if (scopeForTypeParameter instanceof ErrorUtils.ErrorScope) { - result[0] = type(ErrorUtils.createErrorType("?")); - } - else { - result[0] = type(new JetTypeImpl( - annotations, - typeParameterDescriptor.getTypeConstructor(), - TypeUtils.hasNullableLowerBound(typeParameterDescriptor), - Collections.emptyList(), - scopeForTypeParameter - )); - } - - resolveTypeProjections(c, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments()); - - DeclarationDescriptor containing = typeParameterDescriptor.getContainingDeclaration(); - if (containing instanceof ClassDescriptor) { - DescriptorResolver.checkHasOuterClassInstance(c.scope, c.trace, referenceExpression, (ClassDescriptor) containing); - } - } - else if (classifierDescriptor instanceof ClassDescriptor) { - ClassDescriptor classDescriptor = (ClassDescriptor) classifierDescriptor; - - TypeConstructor typeConstructor = classifierDescriptor.getTypeConstructor(); - List arguments = resolveTypeProjections(c, typeConstructor, type.getTypeArguments()); - List parameters = typeConstructor.getParameters(); - int expectedArgumentCount = parameters.size(); - int actualArgumentCount = arguments.size(); - if (ErrorUtils.isError(classDescriptor)) { - result[0] = type(ErrorUtils.createErrorType("[Error type: " + typeConstructor + "]")); - } - else { - if (actualArgumentCount != expectedArgumentCount) { - if (actualArgumentCount == 0) { - // See docs for PossiblyBareType - if (c.allowBareTypes) { - result[0] = PossiblyBareType.bare(typeConstructor, false); - return; - } - c.trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(type, expectedArgumentCount)); - } - else { - c.trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(type.getTypeArgumentList(), expectedArgumentCount)); - } - } - else { - if (Flexibility.FLEXIBLE_TYPE_CLASSIFIER.asSingleFqName().equals(DescriptorUtils.getFqName(classifierDescriptor)) - && classDescriptor.getTypeConstructor().getParameters().size() == 2) { - // We create flexible types by convention here - // This is not intended to be used in normal users' environments, only for tests and debugger etc - result[0] = type(DelegatingFlexibleType.create( - arguments.get(0).getType(), - arguments.get(1).getType(), - flexibleTypeCapabilitiesProvider.getCapabilities() - )); - return; - } - JetTypeImpl resultingType = new JetTypeImpl( - annotations, - typeConstructor, - false, - arguments, - classDescriptor.getMemberScope(arguments) - ); - result[0] = type(resultingType); - if (c.checkBounds) { - TypeSubstitutor substitutor = TypeSubstitutor.create(resultingType); - for (int i = 0, parametersSize = parameters.size(); i < parametersSize; i++) { - TypeParameterDescriptor parameter = parameters.get(i); - JetType argument = arguments.get(i).getType(); - JetTypeReference typeReference = type.getTypeArguments().get(i).getTypeReference(); - - if (typeReference != null) { - DescriptorResolver.checkBounds(typeReference, argument, parameter, substitutor, c.trace); - } - } - } - } - } - } - } - - @Override - public void visitNullableType(@NotNull JetNullableType nullableType) { - PossiblyBareType baseType = resolveTypeElement(c, annotations, nullableType.getInnerType()); - if (baseType.isNullable()) { - c.trace.report(REDUNDANT_NULLABLE.on(nullableType)); - } - else if (!baseType.isBare() && TypeUtils.hasNullableSuperType(baseType.getActualType())) { - c.trace.report(BASE_WITH_NULLABLE_UPPER_BOUND.on(nullableType, baseType.getActualType())); - } - result[0] = baseType.makeNullable(); - } - - @Override - public void visitFunctionType(@NotNull JetFunctionType type) { - JetTypeReference receiverTypeRef = type.getReceiverTypeReference(); - JetType receiverType = receiverTypeRef == null ? null : resolveType(c.noBareTypes(), receiverTypeRef); - - List parameterTypes = new ArrayList(); - for (JetParameter parameter : type.getParameters()) { - parameterTypes.add(resolveType(c.noBareTypes(), parameter.getTypeReference())); - } - - JetTypeReference returnTypeRef = type.getReturnTypeReference(); - JetType returnType; - if (returnTypeRef != null) { - returnType = resolveType(c.noBareTypes(), returnTypeRef); - } - else { - returnType = KotlinBuiltIns.getInstance().getUnitType(); - } - result[0] = type(KotlinBuiltIns.getInstance().getFunctionType(annotations, receiverType, parameterTypes, returnType)); - } - - @Override - public void visitJetElement(@NotNull JetElement element) { - c.trace.report(UNSUPPORTED.on(element, "Self-types are not supported yet")); - } - }); - } - if (result[0] == null) { - return type(ErrorUtils.createErrorType(typeElement == null ? "No type element" : typeElement.getText())); - } - return result[0]; - } - - private JetScope getScopeForTypeParameter(TypeResolutionContext c, final TypeParameterDescriptor typeParameterDescriptor) { - if (c.checkBounds) { - return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope(); - } - else { - return new LazyScopeAdapter(LockBasedStorageManager.NO_LOCKS.createLazyValue(new Function0() { - @Override - public JetScope invoke() { - return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope(); - } - })); - } - } - - @NotNull - private List resolveTypeProjections( - TypeResolutionContext c, - TypeConstructor constructor, - List argumentElements - ) { - List arguments = new ArrayList(); - for (int i = 0, argumentElementsSize = argumentElements.size(); i < argumentElementsSize; i++) { - JetTypeProjection argumentElement = argumentElements.get(i); - - JetProjectionKind projectionKind = argumentElement.getProjectionKind(); - JetType type; - if (projectionKind == JetProjectionKind.STAR) { - List parameters = constructor.getParameters(); - if (parameters.size() > i) { - TypeParameterDescriptor parameterDescriptor = parameters.get(i); - arguments.add(TypeUtils.makeStarProjection(parameterDescriptor)); - } - else { - arguments.add(new TypeProjectionImpl(OUT_VARIANCE, ErrorUtils.createErrorType("*"))); - } - } - else { - // TODO : handle the Foo case - type = resolveType(c.noBareTypes(), argumentElement.getTypeReference()); - Variance kind = resolveProjectionKind(projectionKind); - if (constructor.getParameters().size() > i) { - TypeParameterDescriptor parameterDescriptor = constructor.getParameters().get(i); - if (kind != INVARIANT && parameterDescriptor.getVariance() != INVARIANT) { - if (kind == parameterDescriptor.getVariance()) { - c.trace.report(REDUNDANT_PROJECTION.on(argumentElement, constructor.getDeclarationDescriptor())); - } - else { - c.trace.report(CONFLICTING_PROJECTION.on(argumentElement, constructor.getDeclarationDescriptor())); - } - } - } - arguments.add(new TypeProjectionImpl(kind, type)); - } - } - return arguments; - } - - @NotNull - public static Variance resolveProjectionKind(@NotNull JetProjectionKind projectionKind) { - Variance kind = null; - switch (projectionKind) { - case IN: - kind = IN_VARIANCE; - break; - case OUT: - kind = OUT_VARIANCE; - break; - case NONE: - kind = INVARIANT; - break; - default: - // NOTE: Star projections must be handled before this method is called - throw new IllegalStateException("Illegal projection kind:" + projectionKind); - } - return kind; - } - - @Nullable - public ClassifierDescriptor resolveClass(JetScope scope, JetUserType userType, BindingTrace trace) { - for (DeclarationDescriptor descriptor : qualifiedExpressionResolver.lookupDescriptorsForUserType(userType, scope, trace)) { - if (descriptor instanceof ClassifierDescriptor) { - ImportsResolver.reportPlatformClassMappedToKotlin(moduleDescriptor, trace, userType, descriptor); - return (ClassifierDescriptor) descriptor; - } - } - return null; - } -} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt new file mode 100644 index 00000000000..4696c86a189 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt @@ -0,0 +1,267 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve + +import org.jetbrains.jet.lang.descriptors.* +import org.jetbrains.jet.lang.descriptors.annotations.Annotations +import org.jetbrains.jet.lang.psi.* +import org.jetbrains.jet.lang.resolve.scopes.JetScope +import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter +import org.jetbrains.jet.lang.types.* +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns +import org.jetbrains.jet.storage.LockBasedStorageManager + +import java.util.ArrayList + +import org.jetbrains.jet.lang.diagnostics.Errors.* +import org.jetbrains.jet.lang.resolve.PossiblyBareType.type +import org.jetbrains.jet.lang.types.Variance.* +import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider +import kotlin.platform.platformStatic + +public class TypeResolver( + private val annotationResolver: AnnotationResolver, + private val qualifiedExpressionResolver: QualifiedExpressionResolver, + private val moduleDescriptor: ModuleDescriptor, + private val flexibleTypeCapabilitiesProvider: FlexibleTypeCapabilitiesProvider +) { + + public open class FlexibleTypeCapabilitiesProvider { + public open fun getCapabilities(): FlexibleTypeCapabilities { + return FlexibleTypeCapabilities.NONE + } + } + + public fun resolveType(scope: JetScope, typeReference: JetTypeReference, trace: BindingTrace, checkBounds: Boolean): JetType { + // bare types are not allowed + return resolveType(TypeResolutionContext(scope, trace, checkBounds, false), typeReference) + } + + public fun resolveType(c: TypeResolutionContext, typeReference: JetTypeReference): JetType { + assert(!c.allowBareTypes, "Use resolvePossiblyBareType() when bare types are allowed") + return resolvePossiblyBareType(c, typeReference).getActualType() + } + + public fun resolvePossiblyBareType(c: TypeResolutionContext, typeReference: JetTypeReference): PossiblyBareType { + val cachedType = c.trace.getBindingContext().get(BindingContext.TYPE, typeReference) + if (cachedType != null) return type(cachedType) + + val annotations = annotationResolver.resolveAnnotationsWithArguments(c.scope, typeReference.getAnnotations(), c.trace) + + val typeElement = typeReference.getTypeElement() + val type = resolveTypeElement(c, annotations, typeElement) + if (!type.isBare()) { + c.trace.record(BindingContext.TYPE, typeReference, type.getActualType()) + } + c.trace.record(BindingContext.TYPE_RESOLUTION_SCOPE, typeReference, c.scope) + + return type + } + + private fun resolveTypeElement(c: TypeResolutionContext, annotations: Annotations, typeElement: JetTypeElement?): PossiblyBareType { + var result: PossiblyBareType? = null + typeElement?.accept(object : JetVisitorVoid() { + override fun visitUserType(type: JetUserType) { + val referenceExpression = type.getReferenceExpression() + val referencedName = type.getReferencedName() + if (referenceExpression == null || referencedName == null) return + + val classifierDescriptor = resolveClass(c.scope, type, c.trace) + if (classifierDescriptor == null) { + resolveTypeProjections(c, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments()) + return + } + + c.trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor) + + when (classifierDescriptor) { + is TypeParameterDescriptor -> { + + val scopeForTypeParameter = getScopeForTypeParameter(c, classifierDescriptor) + result = if (scopeForTypeParameter is ErrorUtils.ErrorScope) + type(ErrorUtils.createErrorType("?")) + else + type(JetTypeImpl( + annotations, + classifierDescriptor.getTypeConstructor(), + TypeUtils.hasNullableLowerBound(classifierDescriptor), + listOf(), + scopeForTypeParameter) + ) + + resolveTypeProjections(c, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments()) + + val containing = classifierDescriptor.getContainingDeclaration() + if (containing is ClassDescriptor) { + DescriptorResolver.checkHasOuterClassInstance(c.scope, c.trace, referenceExpression, containing) + } + } + is ClassDescriptor -> { + val typeConstructor = classifierDescriptor.getTypeConstructor() + val arguments = resolveTypeProjections(c, typeConstructor, type.getTypeArguments()) + val parameters = typeConstructor.getParameters() + val expectedArgumentCount = parameters.size() + val actualArgumentCount = arguments.size() + if (ErrorUtils.isError(classifierDescriptor)) { + result = type(ErrorUtils.createErrorType("[Error type: " + typeConstructor + "]")) + } + else { + if (actualArgumentCount != expectedArgumentCount) { + if (actualArgumentCount == 0) { + // See docs for PossiblyBareType + if (c.allowBareTypes) { + result = PossiblyBareType.bare(typeConstructor, false) + return + } + c.trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(type, expectedArgumentCount)) + } + else { + c.trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(type.getTypeArgumentList(), expectedArgumentCount)) + } + } + else { + if (Flexibility.FLEXIBLE_TYPE_CLASSIFIER.asSingleFqName() == DescriptorUtils.getFqName(classifierDescriptor) + && classifierDescriptor.getTypeConstructor().getParameters().size() == 2) { + // We create flexible types by convention here + // This is not intended to be used in normal users' environments, only for tests and debugger etc + result = type(DelegatingFlexibleType.create( + arguments[0].getType(), + arguments[1].getType(), + flexibleTypeCapabilitiesProvider.getCapabilities()) + ) + return + } + val resultingType = JetTypeImpl(annotations, typeConstructor, false, arguments, classifierDescriptor.getMemberScope(arguments)) + result = type(resultingType) + if (c.checkBounds) { + val substitutor = TypeSubstitutor.create(resultingType) + for (i in parameters.indices) { + val parameter = parameters[i] + val argument = arguments[i].getType() + val typeReference = type.getTypeArguments()[i].getTypeReference() + + if (typeReference != null) { + DescriptorResolver.checkBounds(typeReference, argument, parameter, substitutor, c.trace) + } + } + } + } + } + } + } + } + + override fun visitNullableType(nullableType: JetNullableType) { + val baseType = resolveTypeElement(c, annotations, nullableType.getInnerType()) + if (baseType.isNullable()) { + c.trace.report(REDUNDANT_NULLABLE.on(nullableType)) + } + else if (!baseType.isBare() && TypeUtils.hasNullableSuperType(baseType.getActualType())) { + c.trace.report(BASE_WITH_NULLABLE_UPPER_BOUND.on(nullableType, baseType.getActualType())) + } + result = baseType.makeNullable() + } + + override fun visitFunctionType(type: JetFunctionType) { + val receiverTypeRef = type.getReceiverTypeReference() + val receiverType = if (receiverTypeRef == null) null else resolveType(c.noBareTypes(), receiverTypeRef) + + val parameterTypes = type.getParameters().map { resolveType(c.noBareTypes(), it.getTypeReference()) } + + val returnTypeRef = type.getReturnTypeReference() + val returnType = if (returnTypeRef != null) + resolveType(c.noBareTypes(), returnTypeRef) + else KotlinBuiltIns.getInstance().getUnitType() + result = type(KotlinBuiltIns.getInstance().getFunctionType(annotations, receiverType, parameterTypes, returnType)) + } + + override fun visitJetElement(element: JetElement) { + c.trace.report(UNSUPPORTED.on(element, "Self-types are not supported yet")) + } + }) + return result ?: type(ErrorUtils.createErrorType(typeElement?.getText() ?: "No type element")) + } + + private fun getScopeForTypeParameter(c: TypeResolutionContext, typeParameterDescriptor: TypeParameterDescriptor): JetScope { + if (c.checkBounds) { + return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope() + } + else { + return LazyScopeAdapter(LockBasedStorageManager.NO_LOCKS.createLazyValue { + typeParameterDescriptor.getUpperBoundsAsType().getMemberScope() + }) + } + } + + private fun resolveTypeProjections(c: TypeResolutionContext, constructor: TypeConstructor, argumentElements: List): List { + return argumentElements.withIndices().map { + val (i, argumentElement) = it + + val projectionKind = argumentElement.getProjectionKind() + if (projectionKind == JetProjectionKind.STAR) { + val parameters = constructor.getParameters() + if (parameters.size() > i) { + val parameterDescriptor = parameters[i] + TypeUtils.makeStarProjection(parameterDescriptor) + } + else { + TypeProjectionImpl(OUT_VARIANCE, ErrorUtils.createErrorType("*")) + } + } + else { + // TODO : handle the Foo case + val type = resolveType(c.noBareTypes(), argumentElement.getTypeReference()) + val kind = resolveProjectionKind(projectionKind) + if (constructor.getParameters().size() > i) { + val parameterDescriptor = constructor.getParameters()[i] + if (kind != INVARIANT && parameterDescriptor.getVariance() != INVARIANT) { + if (kind == parameterDescriptor.getVariance()) { + c.trace.report(REDUNDANT_PROJECTION.on(argumentElement, constructor.getDeclarationDescriptor())) + } + else { + c.trace.report(CONFLICTING_PROJECTION.on(argumentElement, constructor.getDeclarationDescriptor())) + } + } + } + TypeProjectionImpl(kind, type) + } + + } + } + + public fun resolveClass(scope: JetScope, userType: JetUserType, trace: BindingTrace): ClassifierDescriptor? { + val classifierDescriptor = qualifiedExpressionResolver.lookupDescriptorsForUserType(userType, scope, trace) + .filterIsInstance(javaClass()).firstOrNull() + if (classifierDescriptor != null) { + ImportsResolver.reportPlatformClassMappedToKotlin(moduleDescriptor, trace, userType, classifierDescriptor) + } + return classifierDescriptor + } + + class object { + [platformStatic] + public fun resolveProjectionKind(projectionKind: JetProjectionKind): Variance { + return when (projectionKind) { + JetProjectionKind.IN -> IN_VARIANCE + JetProjectionKind.OUT -> OUT_VARIANCE + JetProjectionKind.NONE -> INVARIANT + else -> // NOTE: Star projections must be handled before this method is called + throw IllegalStateException("Illegal projection kind:" + projectionKind) + } + } + } +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java index 2656425be67..d4d83036b10 100644 --- a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java @@ -38,8 +38,8 @@ import org.jetbrains.jet.lang.types.expressions.ForLoopConventionsChecker; import org.jetbrains.jet.lang.reflect.ReflectionTypes; import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; -import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -69,8 +69,8 @@ public class InjectorForTests { private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final CallResolverExtensionProvider callResolverExtensionProvider; - private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final QualifiedExpressionResolver qualifiedExpressionResolver; + private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; public InjectorForTests( @NotNull Project project, @@ -84,11 +84,13 @@ public class InjectorForTests { this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.callResolver = new CallResolver(); this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), callResolver); - this.typeResolver = new TypeResolver(); + this.annotationResolver = new AnnotationResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider); this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext(); this.storageManager = globalContext.getStorageManager(); this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$; - this.annotationResolver = new AnnotationResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -98,8 +100,6 @@ public class InjectorForTests { this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.descriptorResolver.setAnnotationResolver(annotationResolver); this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -115,11 +115,6 @@ public class InjectorForTests { this.expressionTypingServices.setProject(project); this.expressionTypingServices.setTypeResolver(typeResolver); - this.typeResolver.setAnnotationResolver(annotationResolver); - this.typeResolver.setFlexibleTypeCapabilitiesProvider(flexibleTypeCapabilitiesProvider); - this.typeResolver.setModuleDescriptor(moduleDescriptor); - this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); - annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); annotationResolver.setTypeResolver(typeResolver); diff --git a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index b7ea13d0776..91ad1df7c32 100644 --- a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -40,8 +40,8 @@ import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; @@ -88,8 +88,8 @@ public class InjectorForTopDownAnalyzerForJs { private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; - private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final QualifiedExpressionResolver qualifiedExpressionResolver; + private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final CallResolverExtensionProvider callResolverExtensionProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -135,9 +135,9 @@ public class InjectorForTopDownAnalyzerForJs { this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.typeResolver = new TypeResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), flexibleTypeCapabilitiesProvider); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); @@ -229,11 +229,6 @@ public class InjectorForTopDownAnalyzerForJs { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); - typeResolver.setAnnotationResolver(annotationResolver); - typeResolver.setFlexibleTypeCapabilitiesProvider(flexibleTypeCapabilitiesProvider); - typeResolver.setModuleDescriptor(moduleDescriptor); - typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); - candidateResolver.setArgumentTypeResolver(argumentTypeResolver); controlFlowAnalyzer.setTrace(bindingTrace);