'reportTypeInferenceFailed' moved to tracing

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

@@ -318,7 +318,7 @@ public class CallResolver {
                 }
                 continue;
             }
-            completeTypeInferenceDependentOnExpectedTypeForCall(resolvedCall, context, successful, failed);
+            completeTypeInferenceDependentOnExpectedTypeForCall(resolvedCall, context, tracing, successful, failed);
         }
         if (results.getResultingCalls().size() > 1) {
             for (ResolvedCallWithTrace<D> call : successful) {
@@ -329,16 +329,15 @@ public class CallResolver {
             }
             successful.clear();
         }
-        if (tracing == null) {
-            return results;
-        }
         return computeResultAndReportErrors(context.trace, tracing, successful, failed);
     }
 
     private <D extends CallableDescriptor> void completeTypeInferenceDependentOnExpectedTypeForCall(ResolvedCallImpl<D> resolvedCall,
             BasicResolutionContext context,
+            TracingStrategy tracing,
             Set<ResolvedCallWithTrace<D>> successful,
-            Set<ResolvedCallWithTrace<D>> failed) {
+            Set<ResolvedCallWithTrace<D>> failed
+    ) {
         assert resolvedCall.hasUnknownTypeParameters();
         D descriptor = resolvedCall.getCandidateDescriptor();
         ConstraintsSystem constraintsSystem = resolvedCall.getConstraintsSystem();
@@ -365,8 +364,8 @@ public class CallResolver {
         if (!constraintsSystem.isSuccessful()) {
             List<JetType> argumentTypes = checkValueArgumentTypes(context, resolvedCall, context.trace).argumentTypes;
             JetType receiverType = resolvedCall.getReceiverArgument().exists() ? resolvedCall.getReceiverArgument().getType() : null;
-            reportTypeInferenceFailed(context.trace, context.call, InferenceErrorData.create(descriptor, constraintsSystem,
+            tracing.typeInferenceFailed(context.trace,
-                                                                                             argumentTypes, receiverType));
+                                        InferenceErrorData.create(descriptor, constraintsSystem, argumentTypes, receiverType));
             resolvedCall.addStatus(ResolutionStatus.TYPE_INFERENCE_ERROR);
             failed.add(resolvedCall);
             return;
@@ -380,7 +379,7 @@ public class CallResolver {
         // Here we type check the arguments with inferred types expected
         checkValueArgumentTypes(context, resolvedCall, context.trace);
 
-        checkBounds(resolvedCall, constraintsSystem, context);
+        checkBounds(resolvedCall, constraintsSystem, context.trace, tracing);
         resolvedCall.setHasUnknownTypeParameters(false);
         if (resolvedCall.getStatus().isSuccess() || resolvedCall.getStatus() == ResolutionStatus.UNKNOWN_STATUS) {
             resolvedCall.addStatus(ResolutionStatus.SUCCESS);
@@ -391,28 +390,15 @@ public class CallResolver {
         }
     }
 
-    private void reportTypeInferenceFailed(@NotNull BindingTrace trace, @NotNull Call call, @NotNull InferenceErrorData inferenceErrorData) {
+    private <D extends CallableDescriptor> void checkBounds(
-        assert !inferenceErrorData.constraintsSystem.isSuccessful();
+            @NotNull ResolvedCallImpl<D> call,
-        if (inferenceErrorData.constraintsSystem.hasErrorInConstrainingTypes()) return;
+            @NotNull ConstraintsSystem constraintsSystem,
-        JetExpression calleeExpression = call.getCalleeExpression();
+            @NotNull BindingTrace trace,
-        PsiElement element = calleeExpression != null ? calleeExpression : call.getCallElement();
+            @NotNull TracingStrategy tracing
-        if (inferenceErrorData.constraintsSystem.hasTypeConstructorMismatch()) {
+    ) {
-            trace.report(TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH.on(element, inferenceErrorData));
-        }
-        else if (inferenceErrorData.constraintsSystem.hasConflictingConstraints()) {
-            trace.report(TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS.on(element, inferenceErrorData));
-        }
-        else {
-            assert inferenceErrorData.constraintsSystem.hasUnknownParameters();
-            trace.report(TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER.on(element, inferenceErrorData));
-        }
-    }
-
-    private <D extends CallableDescriptor> void checkBounds(ResolvedCallImpl<D> call, ConstraintsSystem constraintsSystem, BasicResolutionContext context) {
         for (TypeParameterDescriptor typeParameter : call.getCandidateDescriptor().getTypeParameters()) {
             if (!ConstraintsUtil.checkUpperBoundIsSatisfied(constraintsSystem, typeParameter)) {
-                context.trace.report(Errors.TYPE_INFERENCE_UPPER_BOUND_VIOLATED.on(context.call.getCallElement(), InferenceErrorData
+                tracing.upperBoundViolated(trace, InferenceErrorData.create(call.getCandidateDescriptor(), constraintsSystem));
-                        .create(call.getCandidateDescriptor(), constraintsSystem)));
             }
         }
     }
@@ -774,8 +760,8 @@ public class CallResolver {
             ResolutionStatus argumentsStatus = checkingResult.status;
             List<JetType> argumentTypes = checkingResult.argumentTypes;
             JetType receiverType = candidateCall.getReceiverArgument().exists() ? candidateCall.getReceiverArgument().getType() : null;
-            reportTypeInferenceFailed(context.trace, context.call, InferenceErrorData.create(candidate,
+            context.tracing.typeInferenceFailed(context.trace,
-                                                                                             constraintsBuilderWithRightTypeParameters, argumentTypes, receiverType));
+                InferenceErrorData.create(candidate, constraintsBuilderWithRightTypeParameters, argumentTypes, receiverType));
             return TYPE_INFERENCE_ERROR.combine(argumentsStatus);
         }
     }

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

@@ -26,7 +26,7 @@ public enum ResolutionStatus {
     UNSAFE_CALL_ERROR,
     OTHER_ERROR,
     STRONG_ERROR,
-    TYPE_INFERENCE_ERROR,
+    TYPE_INFERENCE_ERROR, //todo remove
     SUCCESS(true);
 
     @SuppressWarnings("unchecked")

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

@@ -23,9 +23,11 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
+import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
+import org.jetbrains.jet.lang.resolve.calls.inference.InferenceErrorData;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
@@ -229,5 +231,28 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends R
         public void invisibleMember(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor descriptor) {
             trace.report(INVISIBLE_MEMBER.on(call.getCallElement(), descriptor, descriptor.getContainingDeclaration()));
         }
+
+        @Override
+        public void typeInferenceFailed(@NotNull BindingTrace trace, @NotNull InferenceErrorData inferenceErrorData) {
+            assert !inferenceErrorData.constraintsSystem.isSuccessful();
+            if (inferenceErrorData.constraintsSystem.hasErrorInConstrainingTypes()) {
+                return;
+            }
+            if (inferenceErrorData.constraintsSystem.hasTypeConstructorMismatch()) {
+                trace.report(TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH.on(reference, inferenceErrorData));
+            }
+            else if (inferenceErrorData.constraintsSystem.hasConflictingConstraints()) {
+                trace.report(TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS.on(reference, inferenceErrorData));
+            }
+            else {
+                assert inferenceErrorData.constraintsSystem.hasUnknownParameters();
+                trace.report(TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER.on(reference, inferenceErrorData));
+            }
+        }
+
+        @Override
+        public void upperBoundViolated(@NotNull BindingTrace trace, @NotNull InferenceErrorData inferenceErrorData) {
+            trace.report(Errors.TYPE_INFERENCE_UPPER_BOUND_VIOLATED.on(reference, inferenceErrorData));
+        }
     };
 }

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

@@ -22,6 +22,7 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.calls.inference.InferenceErrorData;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 
@@ -81,7 +82,14 @@ import java.util.List;
 
         @Override
         public void invisibleMember(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor descriptor) {}
+
+        @Override
+        public void typeInferenceFailed(@NotNull BindingTrace trace, @NotNull InferenceErrorData inferenceErrorData) {}
+
+        @Override
+        public void upperBoundViolated(@NotNull BindingTrace trace, @NotNull InferenceErrorData inferenceErrorData) {}
     };
+
     <D extends CallableDescriptor> void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallWithTrace<D> resolvedCall);
 
     <D extends CallableDescriptor> void bindResolvedCall(@NotNull BindingTrace trace, @NotNull ResolvedCallWithTrace<D> resolvedCall);
@@ -113,4 +121,8 @@ import java.util.List;
     void danglingFunctionLiteralArgumentSuspected(@NotNull BindingTrace trace, @NotNull List<JetExpression> functionLiteralArguments);
 
     void invisibleMember(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor descriptor);
+
+    void typeInferenceFailed(@NotNull BindingTrace trace, @NotNull InferenceErrorData inferenceErrorData);
+
+    void upperBoundViolated(@NotNull BindingTrace trace, @NotNull InferenceErrorData inferenceErrorData);
 }

compiler/testData/diagnostics/tests/regressions/kt1489_1728.kt

@@ -18,9 +18,9 @@ class C {
     fun p() : Resource? = null
 
     fun bar() {
-        <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo(p()) {
+        <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo<!>(p()) {
 
-        }<!>
+        }
     }
 }