TypeResolver converted to Kotlin

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);

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);

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);

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);

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);

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);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java

@@ -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;
-    }
-}

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<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)
+            }
+        }
+    }
+}

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);

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);