From 70c5a5ba9e1da81e608c2f4f16656c2cc48aae4f Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Tue, 7 Aug 2012 18:08:52 +0400 Subject: [PATCH] KT-2505 Type mismatch: inferred type is T but T was expected #KT-2505 --- .../jet/lang/resolve/calls/CallResolver.java | 18 +-------- .../calls/OverloadResolutionResults.java | 2 + .../calls/OverloadResolutionResultsImpl.java | 37 ++++++++++++++----- .../BasicExpressionTypingVisitor.java | 9 +---- .../completeInferenceIfManyFailed.kt | 15 ++++++++ .../tests/inference/regressions/kt2505.kt | 20 ++++++++++ .../checkers/JetDiagnosticsTestGenerated.java | 15 ++++++++ 7 files changed, 83 insertions(+), 33 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt create mode 100644 compiler/testData/diagnostics/tests/inference/regressions/kt2505.kt 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 0142f4e1d9a..9afda1d11fd 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 @@ -591,7 +591,7 @@ public class CallResolver { OverloadResolutionResultsImpl results = computeResultAndReportErrors(task.trace, task.tracing, successfulCandidates, failedCandidates); - if (!results.isSingleResult() && results.getResultCode() != OverloadResolutionResults.Code.INCOMPLETE_TYPE_INFERENCE) { + if (!results.isSingleResult() && !results.isIncomplete()) { checkTypesWithNoCallee(task.toBasic()); } return results; @@ -1033,7 +1033,7 @@ public class CallResolver { } if (!thisLevel.isEmpty()) { OverloadResolutionResultsImpl results = chooseAndReportMaximallySpecific(thisLevel, false); - if (results.isSuccess()) { + if (results.isSingleResult()) { results.getResultingCall().getTrace().commit(); return OverloadResolutionResultsImpl.singleFailedCandidate(results.getResultingCall()); } @@ -1058,9 +1058,6 @@ public class CallResolver { ResolvedCallWithTrace failed = failedCandidates.iterator().next(); failed.getTrace().commit(); - if (failed.getStatus() != ResolutionStatus.STRONG_ERROR && failed.hasUnknownTypeParameters()) { - return OverloadResolutionResultsImpl.incompleteTypeInference(failed); - } return OverloadResolutionResultsImpl.singleFailedCandidate(failed); } else { @@ -1078,13 +1075,9 @@ public class CallResolver { private OverloadResolutionResultsImpl chooseAndReportMaximallySpecific(Set> candidates, boolean discriminateGenerics) { if (candidates.size() != 1) { - boolean dirty = false; Set> cleanCandidates = Sets.newLinkedHashSet(candidates); for (Iterator> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) { ResolvedCallWithTrace candidate = iterator.next(); - if (candidate.hasUnknownTypeParameters()) { - dirty = true; - } if (candidate.isDirty()) { iterator.remove(); } @@ -1107,10 +1100,6 @@ public class CallResolver { Set> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT); - if (dirty) { - return OverloadResolutionResultsImpl.incompleteTypeInference(candidates); - } - return OverloadResolutionResultsImpl.ambiguity(noOverrides); } else { @@ -1118,9 +1107,6 @@ public class CallResolver { TemporaryBindingTrace temporaryTrace = result.getTrace(); temporaryTrace.commit(); - if (result.hasUnknownTypeParameters()) { - return OverloadResolutionResultsImpl.incompleteTypeInference(result); - } return OverloadResolutionResultsImpl.success(result); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java index d1c148858d8..07de185bf28 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java @@ -63,4 +63,6 @@ public interface OverloadResolutionResults { boolean isNothing(); boolean isAmbiguity(); + + boolean isIncomplete(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java index db3fd1aa4e3..34dfc0c87d7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java @@ -28,8 +28,11 @@ import java.util.Collections; */ /*package*/ class OverloadResolutionResultsImpl implements OverloadResolutionResults { - public static OverloadResolutionResultsImpl success(@NotNull ResolvedCallWithTrace descriptor) { - return new OverloadResolutionResultsImpl(Code.SUCCESS, Collections.singleton(descriptor)); + public static OverloadResolutionResultsImpl success(@NotNull ResolvedCallWithTrace candidate) { + if (candidate.hasUnknownTypeParameters()) { + return incompleteTypeInference(candidate); + } + return new OverloadResolutionResultsImpl(Code.SUCCESS, Collections.singleton(candidate)); } public static OverloadResolutionResultsImpl nameNotFound() { @@ -37,22 +40,30 @@ import java.util.Collections; } public static OverloadResolutionResultsImpl singleFailedCandidate(ResolvedCallWithTrace candidate) { + if (candidate.getStatus() != ResolutionStatus.STRONG_ERROR && candidate.hasUnknownTypeParameters()) { + return incompleteTypeInference(candidate); + } return new OverloadResolutionResultsImpl(Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH, Collections.singleton(candidate)); } public static OverloadResolutionResultsImpl manyFailedCandidates(Collection> failedCandidates) { return new OverloadResolutionResultsImpl(Code.MANY_FAILED_CANDIDATES, failedCandidates); } - public static OverloadResolutionResultsImpl ambiguity(Collection> descriptors) { - return new OverloadResolutionResultsImpl(Code.AMBIGUITY, descriptors); + public static OverloadResolutionResultsImpl ambiguity(Collection> candidates) { + for (ResolvedCallWithTrace candidate : candidates) { + if (candidate.hasUnknownTypeParameters()) { + return incompleteTypeInference(candidates); + } + } + return new OverloadResolutionResultsImpl(Code.AMBIGUITY, candidates); } - public static OverloadResolutionResultsImpl incompleteTypeInference(Collection> descriptors) { - return new OverloadResolutionResultsImpl(Code.INCOMPLETE_TYPE_INFERENCE, descriptors); + private static OverloadResolutionResultsImpl incompleteTypeInference(Collection> candidates) { + return new OverloadResolutionResultsImpl(Code.INCOMPLETE_TYPE_INFERENCE, candidates); } - public static OverloadResolutionResultsImpl incompleteTypeInference(ResolvedCallWithTrace descriptor) { - return new OverloadResolutionResultsImpl(Code.INCOMPLETE_TYPE_INFERENCE, Collections.singleton(descriptor)); + private static OverloadResolutionResultsImpl incompleteTypeInference(ResolvedCallWithTrace candidate) { + return incompleteTypeInference(Collections.singleton(candidate)); } private final Collection> results; @@ -96,7 +107,7 @@ import java.util.Collections; @Override public boolean isSingleResult() { - return isSuccess() || resultCode == Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH; + return results.size() == 1; } @Override @@ -108,7 +119,13 @@ import java.util.Collections; public boolean isAmbiguity() { return resultCode == Code.AMBIGUITY; } -// + + @Override + public boolean isIncomplete() { + return resultCode == Code.INCOMPLETE_TYPE_INFERENCE; + } + + // // public OverloadResolutionResultsImpl newContents(@NotNull Collection functionDescriptors) { // return new OverloadResolutionResultsImpl(resultCode, functionDescriptors); // } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index b4c5a409669..34b4b035276 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -611,13 +611,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (!results.isNothing()) { checkSuper(receiver, results, context.trace, callExpression); result[0] = true; - if (results.isSingleResult()) { - ResolvedCall resultingCall = results.getResultingCall(); - if (resultingCall instanceof ResolvedCallWithTrace) { - if (((ResolvedCallWithTrace)resultingCall).getStatus() == ResolutionStatus.TYPE_INFERENCE_ERROR) { - return null; - } - } + if (results.isIncomplete()) { + return null; } return results.isSingleResult() ? results.getResultingDescriptor() : null; } diff --git a/compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt b/compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt new file mode 100644 index 00000000000..a2b71f068af --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt @@ -0,0 +1,15 @@ +package d + +fun joinT(x: Int, vararg a: T): T? { + return null +} + +fun joinT(x: Any, y: T): T? { + return null +} + +fun test() { + val x2 = joinT(*1, "2") + x2 : String? +} + diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2505.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2505.kt new file mode 100644 index 00000000000..b3c9fdfe9b8 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2505.kt @@ -0,0 +1,20 @@ +//KT-2505 Type mismatch: inferred type is T but T was expected + +package a + +trait MyType {} +class MyClass : MyType {} + +public open class HttpResponse() { + public open fun parseAs(dataClass : MyClass) : T? { + return null + } + public open fun parseAs(dataType : MyType) : Any? { + return null + } +} + +fun test (httpResponse: HttpResponse, rtype: MyClass) { + val res = httpResponse.parseAs( rtype ) + res : R? //type mismatch: required R?, found T? +} diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index 59bfdeeda34..c7a27aaba1f 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -1259,6 +1259,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage doTest("compiler/testData/diagnostics/tests/inference/arrayConstructor.kt"); } + @TestMetadata("completeInferenceIfManyFailed.kt") + public void testCompleteInferenceIfManyFailed() throws Exception { + doTest("compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt"); + } + @TestMetadata("conflictingSubstitutions.kt") public void testConflictingSubstitutions() throws Exception { doTest("compiler/testData/diagnostics/tests/inference/conflictingSubstitutions.kt"); @@ -1324,6 +1329,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage doTest("compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt"); } + @TestMetadata("possibleCycleOnConstraints.kt") + public void testPossibleCycleOnConstraints() throws Exception { + doTest("compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt"); + } + @TestMetadata("typeConstructorMismatch.kt") public void testTypeConstructorMismatch() throws Exception { doTest("compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt"); @@ -1405,6 +1415,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage doTest("compiler/testData/diagnostics/tests/inference/regressions/kt2484.kt"); } + @TestMetadata("kt2505.kt") + public void testKt2505() throws Exception { + doTest("compiler/testData/diagnostics/tests/inference/regressions/kt2505.kt"); + } + @TestMetadata("kt2514.kt") public void testKt2514() throws Exception { doTest("compiler/testData/diagnostics/tests/inference/regressions/kt2514.kt");