ArgumentTypeResolver introduce

(component used in CallResolver)

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -35,10 +35,11 @@ import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
-import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
+import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
+import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
@@ -82,10 +83,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private DeclarationResolver declarationResolver;
     private AnnotationResolver annotationResolver;
     private CallResolver callResolver;
-    private CandidateResolver candidateResolver;
+    private ArgumentTypeResolver argumentTypeResolver;
     private ExpressionTypingServices expressionTypingServices;
     private TypeResolver typeResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
+    private CandidateResolver candidateResolver;
     private ImportsResolver importsResolver;
     private ScriptHeaderResolver scriptHeaderResolver;
     private OverloadResolver overloadResolver;
@@ -130,10 +132,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.declarationResolver = new DeclarationResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
-        this.candidateResolver = new CandidateResolver();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
         this.expressionTypingServices = new ExpressionTypingServices();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
+        this.candidateResolver = new CandidateResolver();
         this.importsResolver = new ImportsResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.overloadResolver = new OverloadResolver();
@@ -213,12 +216,13 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         annotationResolver.setCallResolver(callResolver);
         annotationResolver.setExpressionTypingServices(expressionTypingServices);
 
+        callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
         callResolver.setTypeResolver(typeResolver);
 
-        candidateResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        candidateResolver.setTypeResolver(typeResolver);
+        argumentTypeResolver.setTypeResolver(typeResolver);
 
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
@@ -230,6 +234,10 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
+        candidateResolver.setExpressionTypingServices(expressionTypingServices);
+        candidateResolver.setTypeResolver(typeResolver);
+
         importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java

@@ -24,12 +24,13 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
-import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
+import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
+import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer;
 import org.jetbrains.jet.lang.resolve.DeclarationsChecker;
 import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
@@ -47,12 +48,13 @@ public class InjectorForBodyResolve {
     private final BodiesResolveContext bodiesResolveContext;
     private final ModuleConfiguration moduleConfiguration;
     private CallResolver callResolver;
-    private CandidateResolver candidateResolver;
+    private ArgumentTypeResolver argumentTypeResolver;
     private ExpressionTypingServices expressionTypingServices;
     private DescriptorResolver descriptorResolver;
     private AnnotationResolver annotationResolver;
     private TypeResolver typeResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
+    private CandidateResolver candidateResolver;
     private ControlFlowAnalyzer controlFlowAnalyzer;
     private DeclarationsChecker declarationsChecker;
     private ScriptBodyResolver scriptBodyResolver;
@@ -72,12 +74,13 @@ public class InjectorForBodyResolve {
         this.bodiesResolveContext = bodiesResolveContext;
         this.moduleConfiguration = moduleConfiguration;
         this.callResolver = new CallResolver();
-        this.candidateResolver = new CandidateResolver();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
         this.expressionTypingServices = new ExpressionTypingServices();
         this.descriptorResolver = new DescriptorResolver();
         this.annotationResolver = new AnnotationResolver();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
+        this.candidateResolver = new CandidateResolver();
         this.controlFlowAnalyzer = new ControlFlowAnalyzer();
         this.declarationsChecker = new DeclarationsChecker();
         this.scriptBodyResolver = new ScriptBodyResolver();
@@ -93,12 +96,13 @@ public class InjectorForBodyResolve {
         this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters);
         this.bodyResolver.setTrace(bindingTrace);
 
+        callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
         callResolver.setTypeResolver(typeResolver);
 
-        candidateResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        candidateResolver.setTypeResolver(typeResolver);
+        argumentTypeResolver.setTypeResolver(typeResolver);
 
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
@@ -117,6 +121,10 @@ public class InjectorForBodyResolve {
         typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
+        candidateResolver.setExpressionTypingServices(expressionTypingServices);
+        candidateResolver.setTypeResolver(typeResolver);
+
         controlFlowAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters);
         controlFlowAnalyzer.setTrace(bindingTrace);
 

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
+import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
@@ -46,6 +47,7 @@ public class InjectorForLazyResolve {
     private AnnotationResolver annotationResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
     private CallResolver callResolver;
+    private ArgumentTypeResolver argumentTypeResolver;
     private CandidateResolver candidateResolver;
 
     public InjectorForLazyResolve(
@@ -65,6 +67,7 @@ public class InjectorForLazyResolve {
         this.annotationResolver = new AnnotationResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
         this.callResolver = new CallResolver();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
         this.candidateResolver = new CandidateResolver();
 
         this.descriptorResolver.setAnnotationResolver(annotationResolver);
@@ -84,10 +87,15 @@ public class InjectorForLazyResolve {
         this.annotationResolver.setCallResolver(callResolver);
         this.annotationResolver.setExpressionTypingServices(expressionTypingServices);
 
+        callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
         callResolver.setTypeResolver(typeResolver);
 
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setTypeResolver(typeResolver);
+
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
         candidateResolver.setExpressionTypingServices(expressionTypingServices);
         candidateResolver.setTypeResolver(typeResolver);
 

compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java

@@ -21,11 +21,12 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
-import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
+import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
+import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -36,11 +37,12 @@ public class InjectorForMacros {
     private final Project project;
     private final ModuleConfiguration moduleConfiguration;
     private CallResolver callResolver;
-    private CandidateResolver candidateResolver;
+    private ArgumentTypeResolver argumentTypeResolver;
     private TypeResolver typeResolver;
     private AnnotationResolver annotationResolver;
     private DescriptorResolver descriptorResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
+    private CandidateResolver candidateResolver;
 
     public InjectorForMacros(
         @NotNull Project project,
@@ -50,23 +52,25 @@ public class InjectorForMacros {
         this.project = project;
         this.moduleConfiguration = moduleConfiguration;
         this.callResolver = new CallResolver();
-        this.candidateResolver = new CandidateResolver();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
         this.typeResolver = new TypeResolver();
         this.annotationResolver = new AnnotationResolver();
         this.descriptorResolver = new DescriptorResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
+        this.candidateResolver = new CandidateResolver();
 
         this.expressionTypingServices.setCallResolver(callResolver);
         this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
         this.expressionTypingServices.setProject(project);
         this.expressionTypingServices.setTypeResolver(typeResolver);
 
+        callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
         callResolver.setTypeResolver(typeResolver);
 
-        candidateResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        candidateResolver.setTypeResolver(typeResolver);
+        argumentTypeResolver.setTypeResolver(typeResolver);
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
@@ -80,6 +84,10 @@ public class InjectorForMacros {
         descriptorResolver.setExpressionTypingServices(expressionTypingServices);
         descriptorResolver.setTypeResolver(typeResolver);
 
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
+        candidateResolver.setExpressionTypingServices(expressionTypingServices);
+        candidateResolver.setTypeResolver(typeResolver);
+
     }
 
     @PreDestroy

compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java

@@ -33,10 +33,11 @@ import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
-import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
+import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
+import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
@@ -65,10 +66,11 @@ public class InjectorForTopDownAnalyzerBasic {
     private DeclarationResolver declarationResolver;
     private AnnotationResolver annotationResolver;
     private CallResolver callResolver;
-    private CandidateResolver candidateResolver;
+    private ArgumentTypeResolver argumentTypeResolver;
     private ExpressionTypingServices expressionTypingServices;
     private TypeResolver typeResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
+    private CandidateResolver candidateResolver;
     private ImportsResolver importsResolver;
     private ScriptHeaderResolver scriptHeaderResolver;
     private OverloadResolver overloadResolver;
@@ -99,10 +101,11 @@ public class InjectorForTopDownAnalyzerBasic {
         this.declarationResolver = new DeclarationResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
-        this.candidateResolver = new CandidateResolver();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
         this.expressionTypingServices = new ExpressionTypingServices();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
+        this.candidateResolver = new CandidateResolver();
         this.importsResolver = new ImportsResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.overloadResolver = new OverloadResolver();
@@ -156,12 +159,13 @@ public class InjectorForTopDownAnalyzerBasic {
         annotationResolver.setCallResolver(callResolver);
         annotationResolver.setExpressionTypingServices(expressionTypingServices);
 
+        callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
         callResolver.setTypeResolver(typeResolver);
 
-        candidateResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        candidateResolver.setTypeResolver(typeResolver);
+        argumentTypeResolver.setTypeResolver(typeResolver);
 
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
@@ -173,6 +177,10 @@ public class InjectorForTopDownAnalyzerBasic {
         typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
+        candidateResolver.setExpressionTypingServices(expressionTypingServices);
+        candidateResolver.setTypeResolver(typeResolver);
+
         importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2010-2012 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.calls;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.Errors;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.psi.JetTypeProjection;
+import org.jetbrains.jet.lang.psi.JetTypeReference;
+import org.jetbrains.jet.lang.psi.ValueArgument;
+import org.jetbrains.jet.lang.resolve.TypeResolver;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
+
+import javax.inject.Inject;
+
+import java.util.Set;
+
+import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
+
+public class ArgumentTypeResolver {
+    @NotNull
+    private TypeResolver typeResolver;
+    @NotNull
+    private ExpressionTypingServices expressionTypingServices;
+
+    @Inject
+    public void setTypeResolver(@NotNull TypeResolver typeResolver) {
+        this.typeResolver = typeResolver;
+    }
+
+    @Inject
+    public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
+        this.expressionTypingServices = expressionTypingServices;
+    }
+
+    public void checkTypesWithNoCallee(@NotNull ResolutionContext context) {
+        for (ValueArgument valueArgument : context.call.getValueArguments()) {
+            JetExpression argumentExpression = valueArgument.getArgumentExpression();
+            if (argumentExpression != null) {
+                expressionTypingServices.getType(context.scope, argumentExpression, NO_EXPECTED_TYPE, context.dataFlowInfo, context.trace);
+            }
+        }
+
+        for (JetExpression expression : context.call.getFunctionLiteralArguments()) {
+            expressionTypingServices.getType(context.scope, expression, NO_EXPECTED_TYPE, context.dataFlowInfo, context.trace);
+        }
+
+        for (JetTypeProjection typeProjection : context.call.getTypeArguments()) {
+            JetTypeReference typeReference = typeProjection.getTypeReference();
+            if (typeReference == null) {
+                context.trace.report(Errors.PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT.on(typeProjection));
+            }
+            else {
+                typeResolver.resolveType(context.scope, typeReference, context.trace, true);
+            }
+        }
+    }
+
+    public void checkUnmappedArgumentTypes(ResolutionContext context, Set<ValueArgument> unmappedArguments) {
+        for (ValueArgument valueArgument : unmappedArguments) {
+            JetExpression argumentExpression = valueArgument.getArgumentExpression();
+            if (argumentExpression != null) {
+                expressionTypingServices.getType(context.scope, argumentExpression, NO_EXPECTED_TYPE, context.dataFlowInfo, context.trace);
+            }
+        }
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java

@@ -16,8 +16,6 @@
 
 package org.jetbrains.jet.lang.resolve.calls;
 
-import com.google.common.base.Function;
-import com.google.common.collect.Collections2;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.intellij.openapi.progress.ProgressIndicatorProvider;
@@ -40,7 +38,6 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -60,14 +57,14 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
  * @author abreslav
  */
 public class CallResolver {
-    private final JetTypeChecker typeChecker = JetTypeChecker.INSTANCE;
-
     @NotNull
     private ExpressionTypingServices expressionTypingServices;
     @NotNull
     private TypeResolver typeResolver;
     @NotNull
     private CandidateResolver candidateResolver;
+    @NotNull
+    private ArgumentTypeResolver argumentTypeResolver;
 
     @Inject
     public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
@@ -84,6 +81,11 @@ public class CallResolver {
         this.candidateResolver = candidateResolver;
     }
 
+    @Inject
+    public void setArgumentTypeResolver(@NotNull ArgumentTypeResolver argumentTypeResolver) {
+        this.argumentTypeResolver = argumentTypeResolver;
+    }
+
     @NotNull
     public OverloadResolutionResults<VariableDescriptor> resolveSimpleProperty(@NotNull BasicResolutionContext context) {
         JetExpression calleeExpression = context.call.getCalleeExpression();
@@ -341,7 +343,7 @@ public class CallResolver {
         OverloadResolutionResultsImpl<D> results = ResolutionResultsHandler.INSTANCE.computeResultAndReportErrors(
                 context.trace, tracing, candidates);
         if (!results.isSingleResult()) {
-            candidateResolver.checkTypesWithNoCallee(context);
+            argumentTypeResolver.checkTypesWithNoCallee(context);
         }
         return results;
     }
@@ -369,7 +371,7 @@ public class CallResolver {
     }
 
     private <D extends CallableDescriptor> OverloadResolutionResults<D> checkArgumentTypesAndFail(BasicResolutionContext context) {
-        candidateResolver.checkTypesWithNoCallee(context);
+        argumentTypeResolver.checkTypesWithNoCallee(context);
         return OverloadResolutionResultsImpl.nameNotFound();
     }
 
@@ -423,7 +425,7 @@ public class CallResolver {
         }
         else {
             context.trace.report(UNRESOLVED_REFERENCE.on(reference));
-            candidateResolver.checkTypesWithNoCallee(context);
+            argumentTypeResolver.checkTypesWithNoCallee(context);
         }
         return resultsForFirstNonemptyCandidateSet != null ? resultsForFirstNonemptyCandidateSet : OverloadResolutionResultsImpl.<F>nameNotFound();
     }
@@ -515,7 +517,7 @@ public class CallResolver {
         OverloadResolutionResultsImpl<F> results = ResolutionResultsHandler.INSTANCE.computeResultAndReportErrors(
                 task.trace, task.tracing, task.getResolvedCalls());
         if (!results.isSingleResult() && !results.isIncomplete()) {
-            candidateResolver.checkTypesWithNoCallee(task.toBasic());
+            argumentTypeResolver.checkTypesWithNoCallee(task.toBasic());
         }
         return results;
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java

@@ -24,14 +24,12 @@ import com.intellij.openapi.progress.ProgressIndicatorProvider;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.*;
 import org.jetbrains.jet.lang.resolve.calls.inference.*;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl;
-import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.results.ResolutionDebugInfo;
 import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus;
@@ -58,6 +56,8 @@ public class CandidateResolver {
     @NotNull
     private final JetTypeChecker typeChecker = JetTypeChecker.INSTANCE;
     @NotNull
+    private ArgumentTypeResolver argumentTypeResolver;
+    @NotNull
     private TypeResolver typeResolver;
     @NotNull
     private ExpressionTypingServices expressionTypingServices;
@@ -72,28 +72,9 @@ public class CandidateResolver {
         this.typeResolver = typeResolver;
     }
 
-
+    @Inject
-    public void checkTypesWithNoCallee(@NotNull ResolutionContext context) {
+    public void setArgumentTypeResolver(@NotNull ArgumentTypeResolver argumentTypeResolver) {
-        for (ValueArgument valueArgument : context.call.getValueArguments()) {
+        this.argumentTypeResolver = argumentTypeResolver;
-            JetExpression argumentExpression = valueArgument.getArgumentExpression();
-            if (argumentExpression != null) {
-                expressionTypingServices.getType(context.scope, argumentExpression, NO_EXPECTED_TYPE, context.dataFlowInfo, context.trace);
-            }
-        }
-
-        for (JetExpression expression : context.call.getFunctionLiteralArguments()) {
-            expressionTypingServices.getType(context.scope, expression, NO_EXPECTED_TYPE, context.dataFlowInfo, context.trace);
-        }
-
-        for (JetTypeProjection typeProjection : context.call.getTypeArguments()) {
-            JetTypeReference typeReference = typeProjection.getTypeReference();
-            if (typeReference == null) {
-                context.trace.report(Errors.PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT.on(typeProjection));
-            }
-            else {
-                typeResolver.resolveType(context.scope, typeReference, context.trace, true);
-            }
-        }
     }
 
     public <D extends CallableDescriptor, F extends D> void performResolutionForCandidateCall(
@@ -107,7 +88,7 @@ public class CandidateResolver {
 
         if (ErrorUtils.isError(candidate)) {
             candidateCall.addStatus(SUCCESS);
-            checkTypesWithNoCallee(context.toBasic());
+            argumentTypeResolver.checkTypesWithNoCallee(context.toBasic());
             return;
         }
 
@@ -130,10 +111,10 @@ public class CandidateResolver {
             }
             if ((argumentMappingStatus == ValueArgumentsToParametersMapper.Status.ERROR && candidate.getTypeParameters().isEmpty()) ||
                 argumentMappingStatus == ValueArgumentsToParametersMapper.Status.STRONG_ERROR) {
-                checkTypesWithNoCallee(context.toBasic());
+                argumentTypeResolver.checkTypesWithNoCallee(context.toBasic());
                 return;
             }
-            checkUnmappedArgumentTypes(context.toBasic(), unmappedArguments);
+            argumentTypeResolver.checkUnmappedArgumentTypes(context.toBasic(), unmappedArguments);
         }
 
         List<JetTypeProjection> jetTypeArguments = context.call.getTypeArguments();
@@ -377,7 +358,8 @@ public class CandidateResolver {
     }
 
     private <D extends CallableDescriptor, F extends D> ValueArgumentsCheckingResult checkAllValueArguments(CallResolutionContext<D, F> context) {
-        ValueArgumentsCheckingResult checkingResult = checkValueArgumentTypes(context, context.candidateCall, context.candidateCall.getTrace());
+        ValueArgumentsCheckingResult checkingResult = checkValueArgumentTypes(context, context.candidateCall,
+                                                                              context.candidateCall.getTrace());
         ResolutionStatus resultStatus = checkingResult.status;
         ResolvedCall<D> candidateCall = context.candidateCall;
 
@@ -463,15 +445,6 @@ public class CandidateResolver {
         return null;
     }
 
-    private void checkUnmappedArgumentTypes(ResolutionContext context, Set<ValueArgument> unmappedArguments) {
-        for (ValueArgument valueArgument : unmappedArguments) {
-            JetExpression argumentExpression = valueArgument.getArgumentExpression();
-            if (argumentExpression != null) {
-                expressionTypingServices.getType(context.scope, argumentExpression, NO_EXPECTED_TYPE, context.dataFlowInfo, context.trace);
-            }
-        }
-    }
-
     private <D extends CallableDescriptor, F extends D> ResolutionStatus checkReceiver(CallResolutionContext<D, F> context, ResolvedCall<D> candidateCall,
             ReceiverParameterDescriptor receiverParameter, ReceiverValue receiverArgument,
             boolean isExplicitReceiver, boolean implicitInvokeCheck) {

compiler/tests/org/jetbrains/jet/di/InjectorForTests.java

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.ModuleConfiguration;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
+import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
@@ -42,6 +43,7 @@ public class InjectorForTests {
     private final Project project;
     private AnnotationResolver annotationResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
+    private ArgumentTypeResolver argumentTypeResolver;
     private CandidateResolver candidateResolver;
 
     public InjectorForTests(
@@ -56,6 +58,7 @@ public class InjectorForTests {
         this.project = project;
         this.annotationResolver = new AnnotationResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
         this.candidateResolver = new CandidateResolver();
 
         this.descriptorResolver.setAnnotationResolver(annotationResolver);
@@ -72,6 +75,7 @@ public class InjectorForTests {
         this.typeResolver.setModuleConfiguration(moduleConfiguration);
         this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
+        this.callResolver.setArgumentTypeResolver(argumentTypeResolver);
         this.callResolver.setCandidateResolver(candidateResolver);
         this.callResolver.setExpressionTypingServices(expressionTypingServices);
         this.callResolver.setTypeResolver(typeResolver);
@@ -79,6 +83,10 @@ public class InjectorForTests {
         annotationResolver.setCallResolver(callResolver);
         annotationResolver.setExpressionTypingServices(expressionTypingServices);
 
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setTypeResolver(typeResolver);
+
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
         candidateResolver.setExpressionTypingServices(expressionTypingServices);
         candidateResolver.setTypeResolver(typeResolver);
 

js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java

@@ -33,10 +33,11 @@ import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
-import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
+import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
+import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
@@ -65,10 +66,11 @@ public class InjectorForTopDownAnalyzerForJs {
     private DeclarationResolver declarationResolver;
     private AnnotationResolver annotationResolver;
     private CallResolver callResolver;
-    private CandidateResolver candidateResolver;
+    private ArgumentTypeResolver argumentTypeResolver;
     private ExpressionTypingServices expressionTypingServices;
     private TypeResolver typeResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
+    private CandidateResolver candidateResolver;
     private ImportsResolver importsResolver;
     private ScriptHeaderResolver scriptHeaderResolver;
     private OverloadResolver overloadResolver;
@@ -99,10 +101,11 @@ public class InjectorForTopDownAnalyzerForJs {
         this.declarationResolver = new DeclarationResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
-        this.candidateResolver = new CandidateResolver();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
         this.expressionTypingServices = new ExpressionTypingServices();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
+        this.candidateResolver = new CandidateResolver();
         this.importsResolver = new ImportsResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.overloadResolver = new OverloadResolver();
@@ -156,12 +159,13 @@ public class InjectorForTopDownAnalyzerForJs {
         annotationResolver.setCallResolver(callResolver);
         annotationResolver.setExpressionTypingServices(expressionTypingServices);
 
+        callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
         callResolver.setTypeResolver(typeResolver);
 
-        candidateResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        candidateResolver.setTypeResolver(typeResolver);
+        argumentTypeResolver.setTypeResolver(typeResolver);
 
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
@@ -173,6 +177,10 @@ public class InjectorForTopDownAnalyzerForJs {
         typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
+        candidateResolver.setExpressionTypingServices(expressionTypingServices);
+        candidateResolver.setTypeResolver(typeResolver);
+
         importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);