refactoring after code review

do not consider error type in parameters of function type as unknown
JetBrains · Feb 8, 2013 · d149218 · d149218
1 parent cc94c45
commit d149218
Show file tree

Hide file tree

Showing 2 changed files with 10 additions and 21 deletions.
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolverUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolverUtil.java
@@ -21,15 +21,13 @@
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
-import org.jetbrains.jet.lang.psi.ValueArgument;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
 import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintsUtil;
 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.tasks.ResolutionCandidate;
 import org.jetbrains.jet.lang.types.*;
@@ -38,7 +36,6 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 public class CallResolverUtil {
 
@@ -84,17 +81,15 @@ public static <D extends CallableDescriptor> ResolvedCallImpl<D> copy(@NotNull R
     }
 
 
-    public static boolean containsUnknownFunctionArgument(@NotNull JetType type) {
+    public static boolean hasUnknownFunctionParameter(@NotNull JetType type) {
         assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
         List<TypeProjection> arguments = type.getArguments();
-        int index = 0;
-        for (TypeProjection argument : arguments) {
-            if (index < arguments.size() - 1) {
-                if (ErrorUtils.containsErrorType(argument.getType())) {
-                    return true;
-                }
+        // last argument is return type of function type
+        List<TypeProjection> functionParameters = arguments.subList(0, arguments.size() - 1);
+        for (TypeProjection functionParameter : functionParameters) {
+            if (TypeUtils.equalsOrContainsAsArgument(functionParameter.getType(), CANT_INFER, DONT_CARE)) {
+                return true;
             }
-            index++;
         }
         return false;
     }
@@ -105,17 +100,11 @@ public static boolean hasUnknownReturnType(@NotNull JetType type) {
         return ErrorUtils.containsErrorType(returnTypeFromFunctionType);
     }
 
-    public static JetType replaceReturnTypeToUnknown(@NotNull JetType type) {
+    public static JetType replaceReturnTypeByUnknown(@NotNull JetType type) {
         assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
         List<TypeProjection> arguments = type.getArguments();
         List<TypeProjection> newArguments = Lists.newArrayList();
-        int index = 0;
-        for (TypeProjection argument : arguments) {
-            if (index < arguments.size() - 1) {
-                newArguments.add(argument);
-            }
-            index++;
-        }
+        newArguments.addAll(arguments.subList(0, arguments.size() - 1));
         newArguments.add(new TypeProjection(Variance.INVARIANT, DONT_CARE));
         return new JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isNullable(), newArguments, type.getMemberScope());
     }

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
@@ -318,7 +318,7 @@ private <D extends CallableDescriptor> void addConstraintForFunctionLiteral(
         JetType effectiveExpectedType = getEffectiveExpectedType(valueParameterDescriptor, valueArgument);
         JetType expectedType = constraintSystem.getCurrentSubstitutor().substitute(effectiveExpectedType, Variance.INVARIANT);
         if (expectedType == null || !KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(expectedType)
-                || CallResolverUtil.containsUnknownFunctionArgument(expectedType)) {
+                || CallResolverUtil.hasUnknownFunctionParameter(expectedType)) {
             return;
         }
         boolean hasExpectedReturnType = !CallResolverUtil.hasUnknownReturnType(expectedType);
@@ -342,7 +342,7 @@ private <D extends CallableDescriptor> void addConstraintForFunctionLiteral(
             }
             BindingContextUtils.commitResolutionCacheData(traceToResolveFunctionLiteral, context.trace);
         }
-        JetType expectedTypeWithoutReturnType = hasExpectedReturnType ? CallResolverUtil.replaceReturnTypeToUnknown(expectedType) : expectedType;
+        JetType expectedTypeWithoutReturnType = hasExpectedReturnType ? CallResolverUtil.replaceReturnTypeByUnknown(expectedType) : expectedType;
         CallCandidateResolutionContext<D> newContext = context.replaceExpectedType(expectedTypeWithoutReturnType);
         JetType type = argumentTypeResolver.getArgumentTypeInfo(argumentExpression, newContext, RESOLVE_FUNCTION_ARGUMENTS).getType();
         constraintSystem.addSubtypeConstraint(