From ec0fa1b76552599a68d02c37e33bd9e852ed6b25 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Sun, 4 May 2014 20:50:32 +0400 Subject: [PATCH] Rewrote 'isDirty' in terms of argument to parameter match status Added ArgumentMatchStatus --- .../lang/resolve/calls/CandidateResolver.java | 23 ++++--------------- .../resolve/calls/model/ArgumentMapping.kt | 10 ++++++-- .../calls/model/MutableResolvedCall.java | 7 +----- .../resolve/calls/model/ResolvedCallImpl.java | 18 +++------------ .../results/ResolutionResultsHandler.java | 5 ++-- .../resolve/calls/util/resolvedCallUtil.kt | 11 +++++++++ 6 files changed, 31 insertions(+), 43 deletions(-) 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 154cd727e86..a1b6ea6bf38 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 @@ -21,13 +21,11 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Sets; import com.intellij.openapi.progress.ProgressIndicatorProvider; -import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; -import org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage; import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastUtils; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValue; @@ -39,12 +37,10 @@ import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsImp import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus; import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionTask; import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; -import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.expressions.DataFlowUtils; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -298,12 +294,8 @@ public class CandidateResolver { // Here we type check expecting an error type (DONT_CARE, substitution with substituteDontCare) // and throw the results away // We'll type check the arguments later, with the inferred types expected - boolean[] isErrorType = new boolean[1]; addConstraintForValueArgument(valueArgument, valueParameterDescriptor, substituteDontCare, constraintSystem, - context, isErrorType, SHAPE_FUNCTION_ARGUMENTS); - if (isErrorType[0]) { - candidateCall.argumentHasNoType(); - } + context, SHAPE_FUNCTION_ARGUMENTS); } } @@ -349,7 +341,6 @@ public class CandidateResolver { @NotNull TypeSubstitutor substitutor, @NotNull ConstraintSystem constraintSystem, @NotNull CallCandidateResolutionContext context, - @Nullable boolean[] isErrorType, @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies) { JetType effectiveExpectedType = getEffectiveExpectedType(valueParameterDescriptor, valueArgument); @@ -366,9 +357,6 @@ public class CandidateResolver { JetType type = updateResultTypeForSmartCasts(typeInfoForCall.getType(), argumentExpression, dataFlowInfoForArgument, context.trace); constraintSystem.addSubtypeConstraint(type, effectiveExpectedType, ConstraintPosition.getValueParameterPosition( valueParameterDescriptor.getIndex())); - if (isErrorType != null) { - isErrorType[0] = type == null || type.isError(); - } } @Nullable @@ -469,11 +457,10 @@ public class CandidateResolver { JetType type = typeInfoForCall.getType(); infoForArguments.updateInfo(argument, typeInfoForCall.getDataFlowInfo()); - boolean hasTypeMismatch = false; + ArgumentMatchStatus matchStatus = ArgumentMatchStatus.SUCCESS; if (type == null || (type.isError() && type != PLACEHOLDER_FUNCTION_TYPE)) { - candidateCall.argumentHasNoType(); argumentTypes.add(type); - hasTypeMismatch = true; + matchStatus = ArgumentMatchStatus.ARGUMENT_HAS_NO_TYPE; } else { JetType resultingType; @@ -485,13 +472,13 @@ public class CandidateResolver { if (resultingType == null) { resultingType = type; resultStatus = OTHER_ERROR; - hasTypeMismatch = true; + matchStatus = ArgumentMatchStatus.TYPE_MISMATCH; } } argumentTypes.add(resultingType); } - candidateCall.recordArgumentMatch(argument, parameterDescriptor, hasTypeMismatch); + candidateCall.recordArgumentMatch(argument, parameterDescriptor, matchStatus); } } return new ValueArgumentsCheckingResult(resultStatus, argumentTypes); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ArgumentMapping.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ArgumentMapping.kt index 3588529d7f5..69721c4c678 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ArgumentMapping.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ArgumentMapping.kt @@ -26,6 +26,12 @@ object ArgumentUnmapped: ArgumentMapping { override fun isError(): Boolean = true } -class ArgumentMatch(val valueParameter: ValueParameterDescriptor, val hasTypeMismatch: Boolean): ArgumentMapping { - override fun isError(): Boolean = hasTypeMismatch +enum class ArgumentMatchStatus(val isError: Boolean) { + SUCCESS : ArgumentMatchStatus(false) + TYPE_MISMATCH : ArgumentMatchStatus(true) + ARGUMENT_HAS_NO_TYPE : ArgumentMatchStatus(true) +} + +class ArgumentMatch(val valueParameter: ValueParameterDescriptor, val status: ArgumentMatchStatus): ArgumentMapping { + override fun isError(): Boolean = status.isError } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/MutableResolvedCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/MutableResolvedCall.java index baf1dd980f5..f288fb8d467 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/MutableResolvedCall.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/MutableResolvedCall.java @@ -36,11 +36,6 @@ public interface MutableResolvedCall extends Resol void setStatusToSuccess(); - //todo remove: use value to parameter map status - boolean isDirty(); - - void argumentHasNoType(); - @NotNull DelegatingBindingTrace getTrace(); @@ -52,7 +47,7 @@ public interface MutableResolvedCall extends Resol void recordValueArgument(@NotNull ValueParameterDescriptor valueParameter, @NotNull ResolvedValueArgument valueArgument); - void recordArgumentMatch(@NotNull ValueArgument valueArgument, @NotNull ValueParameterDescriptor parameter, boolean hasTypeMismatch); + void recordArgumentMatch(@NotNull ValueArgument valueArgument, @NotNull ValueParameterDescriptor parameter, @NotNull ArgumentMatchStatus matchStatus); @Override @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ResolvedCallImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ResolvedCallImpl.java index d596ebea85b..45796f4de2e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ResolvedCallImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ResolvedCallImpl.java @@ -17,7 +17,6 @@ package org.jetbrains.jet.lang.resolve.calls.model; import com.google.common.collect.Maps; -import com.google.common.collect.Sets; import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -83,7 +82,6 @@ public class ResolvedCallImpl implements MutableRe private final MutableDataFlowInfoForArguments dataFlowInfoForArguments; private final Map argumentToParameterMap = Maps.newHashMap(); - private boolean someArgumentHasNoType = false; private DelegatingBindingTrace trace; private TracingStrategy tracing; private ResolutionStatus status = UNKNOWN_STATUS; @@ -187,7 +185,7 @@ public class ResolvedCallImpl implements MutableRe ArgumentMatch argumentMatch = entry.getValue(); ValueParameterDescriptor substitutedVersion = parameterMap.get(argumentMatch.getValueParameter().getOriginal()); assert substitutedVersion != null : argumentMatch.getValueParameter(); - argumentToParameterMap.put(entry.getKey(), new ArgumentMatch(substitutedVersion, argumentMatch.getHasTypeMismatch())); + argumentToParameterMap.put(entry.getKey(), new ArgumentMatch(substitutedVersion, argumentMatch.getStatus())); } } @@ -262,9 +260,9 @@ public class ResolvedCallImpl implements MutableRe @Override public void recordArgumentMatch( - @NotNull ValueArgument valueArgument, @NotNull ValueParameterDescriptor parameter, boolean hasTypeMismatch + @NotNull ValueArgument valueArgument, @NotNull ValueParameterDescriptor parameter, @NotNull ArgumentMatchStatus matchStatus ) { - argumentToParameterMap.put(valueArgument, new ArgumentMatch(parameter, hasTypeMismatch)); + argumentToParameterMap.put(valueArgument, new ArgumentMatch(parameter, matchStatus)); } @NotNull @@ -277,16 +275,6 @@ public class ResolvedCallImpl implements MutableRe return argumentMatch; } - @Override - public void argumentHasNoType() { - this.someArgumentHasNoType = true; - } - - @Override - public boolean isDirty() { - return someArgumentHasNoType; - } - @NotNull @Override public Map getTypeArguments() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionResultsHandler.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionResultsHandler.java index 65f6629b4c5..f69c3474117 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionResultsHandler.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionResultsHandler.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.calls.model.MutableResolvedCall; import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy; +import org.jetbrains.jet.lang.resolve.calls.util.UtilPackage; import java.util.*; @@ -159,7 +160,7 @@ public class ResolutionResultsHandler { private static boolean allClean(@NotNull Collection> results) { for (MutableResolvedCall result : results) { - if (result.isDirty()) return false; + if (UtilPackage.isDirty(result)) return false; } return true; } @@ -183,7 +184,7 @@ public class ResolutionResultsHandler { Set> cleanCandidates = Sets.newLinkedHashSet(candidates); for (Iterator> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) { MutableResolvedCall candidate = iterator.next(); - if (candidate.isDirty()) { + if (UtilPackage.isDirty(candidate)) { iterator.remove(); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/util/resolvedCallUtil.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/util/resolvedCallUtil.kt index 24e26b5148e..29e97b97d80 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/util/resolvedCallUtil.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/util/resolvedCallUtil.kt @@ -23,6 +23,8 @@ import org.jetbrains.jet.lang.resolve.calls.model.ArgumentUnmapped import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument import org.jetbrains.jet.lang.resolve.calls.model.ArgumentMapping import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor +import org.jetbrains.jet.lang.resolve.calls.model.ArgumentMatch +import org.jetbrains.jet.lang.resolve.calls.model.ArgumentMatchStatus public fun ResolvedCall.noErrorsInValueArguments(): Boolean { return getCall().getValueArguments().all { argument -> !getArgumentMapping(argument!!).isError() } @@ -43,3 +45,12 @@ public fun ResolvedCall.hasErrorOnParameter(paramete return resolvedValueArgument.getArguments().any { argument -> getArgumentMapping(argument).isError() } } + +fun ResolvedCall.isDirty(): Boolean { + return getValueArguments().values() + .flatMap { it.getArguments() } + .any { argument -> + val argumentMapping = getArgumentMapping(argument) + argumentMapping is ArgumentMatch && argumentMapping.status == ArgumentMatchStatus.ARGUMENT_HAS_NO_TYPE + } +}