From 9d5f5f7adf08e9f4b6c0e09ecd2456f0656f7fc9 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Sat, 29 Sep 2012 21:06:24 +0400 Subject: [PATCH] KT-2842 Function with declared non-null receiver resolves with nullable argument receiver #KT-2842 fixed --- .../resolve/calls/CallResolutionContext.java | 13 +++++++++ .../jet/lang/resolve/calls/CallResolver.java | 20 ++++++-------- .../tests/inference/regressions/kt2842.kt | 27 +++++++++++++++++++ .../checkers/JetDiagnosticsTestGenerated.java | 5 ++++ libraries/stdlib/test/StringUtilTest.kt | 2 +- 5 files changed, 54 insertions(+), 13 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/inference/regressions/kt2842.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolutionContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolutionContext.java index e5f8c356056..a6db2f51a33 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolutionContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolutionContext.java @@ -20,7 +20,10 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.psi.Call; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; +import org.jetbrains.jet.lang.types.JetType; /** * @author svtk @@ -36,6 +39,12 @@ public final class CallResolutionContext candidateCall) { + super(context.trace, context.scope, context.call, context.expectedType, context.dataFlowInfo); + this.candidateCall = candidateCall; + this.tracing = tracing; + } + public static CallResolutionContext create(@NotNull ResolvedCallImpl candidateCall, @NotNull ResolutionTask task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing, @NotNull Call call) { return new CallResolutionContext(candidateCall, task, trace, tracing, call); } @@ -43,4 +52,8 @@ public final class CallResolutionContext CallResolutionContext create(@NotNull ResolvedCallImpl candidateCall, @NotNull ResolutionTask task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing) { return create(candidateCall, task, trace, tracing, task.call); } + + public static CallResolutionContext create(@NotNull BasicResolutionContext context, @NotNull TracingStrategy tracing, @NotNull ResolvedCallImpl candidateCall) { + return new CallResolutionContext(context, tracing, candidateCall); + } } 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 54ef4ec182e..c09270c5cd0 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 @@ -328,7 +328,7 @@ public class CallResolver { } continue; } - completeTypeInferenceDependentOnExpectedTypeForCall(resolvedCall, context, tracing, successful, failed); + completeTypeInferenceDependentOnExpectedTypeForCall(CallResolutionContext.create(context, tracing, resolvedCall), successful, failed); } OverloadResolutionResultsImpl results = computeResultAndReportErrors(context.trace, tracing, successful, failed); if (!results.isSingleResult()) { @@ -337,12 +337,12 @@ public class CallResolver { return results; } - private void completeTypeInferenceDependentOnExpectedTypeForCall(ResolvedCallImpl resolvedCall, - BasicResolutionContext context, - TracingStrategy tracing, + private void completeTypeInferenceDependentOnExpectedTypeForCall( + CallResolutionContext context, Set> successful, Set> failed ) { + ResolvedCallImpl resolvedCall = context.candidateCall; assert resolvedCall.hasUnknownTypeParameters(); D descriptor = resolvedCall.getCandidateDescriptor(); ConstraintSystem constraintSystem = resolvedCall.getConstraintSystem(); @@ -383,7 +383,7 @@ public class CallResolver { } List argumentTypes = checkValueArgumentTypes(context, resolvedCall, resolvedCall.getTrace()).argumentTypes; JetType receiverType = resolvedCall.getReceiverArgument().exists() ? resolvedCall.getReceiverArgument().getType() : null; - tracing.typeInferenceFailed(resolvedCall.getTrace(), + context.tracing.typeInferenceFailed(resolvedCall.getTrace(), InferenceErrorData .create(descriptor, constraintSystem, argumentTypes, receiverType, context.expectedType), constraintSystemWithoutExpectedTypeConstraint); @@ -394,9 +394,9 @@ public class CallResolver { resolvedCall.setResultingSubstitutor(constraintSystem.getResultingSubstitutor()); // Here we type check the arguments with inferred types expected - checkValueArgumentTypes(context, resolvedCall, resolvedCall.getTrace()); + checkAllValueArguments(context); - checkBounds(resolvedCall, constraintSystem, resolvedCall.getTrace(), tracing); + checkBounds(resolvedCall, constraintSystem, resolvedCall.getTrace(), context.tracing); resolvedCall.setHasUnknownTypeParameters(false); if (resolvedCall.getStatus().isSuccess() || resolvedCall.getStatus() == ResolutionStatus.UNKNOWN_STATUS) { resolvedCall.addStatus(ResolutionStatus.SUCCESS); @@ -866,7 +866,7 @@ public class CallResolver { private ValueArgumentsCheckingResult checkAllValueArguments(CallResolutionContext context) { - ValueArgumentsCheckingResult checkingResult = checkValueArgumentTypes(context, context.candidateCall); + ValueArgumentsCheckingResult checkingResult = checkValueArgumentTypes(context, context.candidateCall, context.candidateCall.getTrace()); ResolutionStatus resultStatus = checkingResult.status; ResolvedCall candidateCall = context.candidateCall; @@ -927,10 +927,6 @@ public class CallResolver { } } - private ValueArgumentsCheckingResult checkValueArgumentTypes(ResolutionContext context, ResolvedCallImpl candidateCall) { - return checkValueArgumentTypes(context, candidateCall, candidateCall.getTrace()); - } - private ValueArgumentsCheckingResult checkValueArgumentTypes(ResolutionContext context, ResolvedCallImpl candidateCall, BindingTrace trace) { ResolutionStatus resultStatus = SUCCESS; DataFlowInfo dataFlowInfo = context.dataFlowInfo; diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2842.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2842.kt new file mode 100644 index 00000000000..fe3761ca6a1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2842.kt @@ -0,0 +1,27 @@ +package c + +trait A + +fun test(a: A?) { + a.foo() //no error +} + +fun A.foo() {} + +//------------ +fun test(nullabilityInfoMap: Map?) { + nullabilityInfoMap.iterator() //no error +} + +//resolves to +public inline fun Map.iterator(): Iterator> {} + + +//------------- +fun foo() : Boolean { + val nullableList = getNullableList() + return nullableList.contains("") + +} + +fun getNullableList(): List? = null \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index 9e8ace0569f..36506f78444 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -1889,6 +1889,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage doTest("compiler/testData/diagnostics/tests/inference/regressions/kt2514.kt"); } + @TestMetadata("kt2842.kt") + public void testKt2842() throws Exception { + doTest("compiler/testData/diagnostics/tests/inference/regressions/kt2842.kt"); + } + @TestMetadata("kt702.kt") public void testKt702() throws Exception { doTest("compiler/testData/diagnostics/tests/inference/regressions/kt702.kt"); diff --git a/libraries/stdlib/test/StringUtilTest.kt b/libraries/stdlib/test/StringUtilTest.kt index 9e02e9d30df..8e997b3645e 100644 --- a/libraries/stdlib/test/StringUtilTest.kt +++ b/libraries/stdlib/test/StringUtilTest.kt @@ -10,7 +10,7 @@ class StringUtilTest() : TestCase() { fun testToRegex() { val re = """foo""".toRegex() - val list = re.split("hellofoobar").filterNotNull() + val list = re.split("hellofoobar").toList() assertEquals(arrayList("hello", "bar"), list) } }