From 473a96959892c43ee25c2c63a19e931ffbeb48c2 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Tue, 20 Nov 2012 16:38:35 +0400 Subject: [PATCH] ArgumentTypeResolver introduce (component used in CallResolver) --- .../di/InjectorForTopDownAnalyzerForJvm.java | 18 +++-- .../jet/di/InjectorForBodyResolve.java | 18 +++-- .../jet/di/InjectorForLazyResolve.java | 8 ++ .../jetbrains/jet/di/InjectorForMacros.java | 18 +++-- .../di/InjectorForTopDownAnalyzerBasic.java | 18 +++-- .../resolve/calls/ArgumentTypeResolver.java | 81 +++++++++++++++++++ .../jet/lang/resolve/calls/CallResolver.java | 20 ++--- .../lang/resolve/calls/CandidateResolver.java | 47 +++-------- .../jetbrains/jet/di/InjectorForTests.java | 8 ++ .../di/InjectorForTopDownAnalyzerForJs.java | 18 +++-- 10 files changed, 183 insertions(+), 71 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index dd193e892bf..1dee211469a 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/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); - candidateResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); + 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); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java index 76bd4e4304b..cd674b45868 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java +++ b/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); - candidateResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); + 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); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 95630948fee..44239de6fff 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java index aadc8e04c4b..9fd45db5b04 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java +++ b/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); - candidateResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); + 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 diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 22e0607d89e..a5e6d40a3a5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/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); - candidateResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); + 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); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java new file mode 100644 index 00000000000..3a20d3002fa --- /dev/null +++ b/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 unmappedArguments) { + for (ValueArgument valueArgument : unmappedArguments) { + JetExpression argumentExpression = valueArgument.getArgumentExpression(); + if (argumentExpression != null) { + expressionTypingServices.getType(context.scope, argumentExpression, NO_EXPECTED_TYPE, context.dataFlowInfo, context.trace); + } + } + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 8c1a57ced77..49eb5b9043c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/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 resolveSimpleProperty(@NotNull BasicResolutionContext context) { JetExpression calleeExpression = context.call.getCalleeExpression(); @@ -341,7 +343,7 @@ public class CallResolver { OverloadResolutionResultsImpl 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 OverloadResolutionResults 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.nameNotFound(); } @@ -515,7 +517,7 @@ public class CallResolver { OverloadResolutionResultsImpl 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; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java index ca10fcce842..c4d9923ff52 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java +++ b/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; } - - 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); - } - } + @Inject + public void setArgumentTypeResolver(@NotNull ArgumentTypeResolver argumentTypeResolver) { + this.argumentTypeResolver = argumentTypeResolver; } public 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 jetTypeArguments = context.call.getTypeArguments(); @@ -377,7 +358,8 @@ public class CandidateResolver { } private ValueArgumentsCheckingResult checkAllValueArguments(CallResolutionContext context) { - ValueArgumentsCheckingResult checkingResult = checkValueArgumentTypes(context, context.candidateCall, context.candidateCall.getTrace()); + ValueArgumentsCheckingResult checkingResult = checkValueArgumentTypes(context, context.candidateCall, + context.candidateCall.getTrace()); ResolutionStatus resultStatus = checkingResult.status; ResolvedCall candidateCall = context.candidateCall; @@ -463,15 +445,6 @@ public class CandidateResolver { return null; } - private void checkUnmappedArgumentTypes(ResolutionContext context, Set 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 ResolutionStatus checkReceiver(CallResolutionContext context, ResolvedCall candidateCall, ReceiverParameterDescriptor receiverParameter, ReceiverValue receiverArgument, boolean isExplicitReceiver, boolean implicitInvokeCheck) { diff --git a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java index 723cf3cb3e0..4fb5161eb27 100644 --- a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java +++ b/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); diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 9c0afebd76f..e955c51e31e 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/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); - candidateResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); + 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);