TypeResolver converted to Kotlin
This commit is contained in:
Andrey Breslav
@@ -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);
|
||||
|
||||
+1
-6
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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.<TypeProjection>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<TypeProjection> arguments = resolveTypeProjections(c, typeConstructor, type.getTypeArguments());
|
||||
List<TypeParameterDescriptor> 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<JetType> parameterTypes = new ArrayList<JetType>();
|
||||
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<JetScope>() {
|
||||
@Override
|
||||
public JetScope invoke() {
|
||||
return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope();
|
||||
}
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private List<TypeProjection> resolveTypeProjections(
|
||||
TypeResolutionContext c,
|
||||
TypeConstructor constructor,
|
||||
List<JetTypeProjection> argumentElements
|
||||
) {
|
||||
List<TypeProjection> arguments = new ArrayList<TypeProjection>();
|
||||
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<TypeParameterDescriptor> 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<in *> 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;
|
||||
}
|
||||
}
|
||||
@@ -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<JetTypeProjection>): List<TypeProjection> {
|
||||
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<in *> 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<ClassifierDescriptor>()).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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in New Issue
Block a user