From dde0efd8ab1b480a2441ca223f15f9a61d0521c9 Mon Sep 17 00:00:00 2001 From: Mikhail Zarechenskiy Date: Fri, 1 Sep 2017 02:24:35 +0300 Subject: [PATCH] Refactoring: extract anonymous objects to classes, rename variable --- .../types/expressions/FakeCallResolver.kt | 76 +++++++++---------- 1 file changed, 37 insertions(+), 39 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt index 0378af4cc03..93c8b5bafa9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt @@ -59,15 +59,15 @@ class FakeCallResolver( val fakeTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve fake call for", name) val fakeBindingTrace = context.replaceBindingTrace(fakeTrace) - var errorIsMissing = false + var reportIsMissingError = false val realExpression = RealExpression(reportErrorsOn, callKind) val result = makeAndResolveFakeCallInContext(receiver, fakeBindingTrace, valueArguments, name, callElement, realExpression) { fake -> - errorIsMissing = fakeTrace.bindingContext.diagnostics.noSuppression().forElement(fake).any { it.severity == Severity.ERROR } + reportIsMissingError = fakeTrace.bindingContext.diagnostics.noSuppression().forElement(fake).any { it.severity == Severity.ERROR } fakeTrace.commit({ _, key -> key != fake }, true) } val resolutionResults = result.second - if (errorIsMissing) { + if (reportIsMissingError) { val diagnostic = when (callKind) { FakeCallKind.ITERATOR -> Errors.ITERATOR_MISSING.on(reportErrorsOn) FakeCallKind.COMPONENT -> if (receiver != null) Errors.COMPONENT_FUNCTION_MISSING.on(reportErrorsOn, name, receiver.type) else null @@ -82,49 +82,47 @@ class FakeCallResolver( return resolutionResults } - private fun createTracingStrategyForComponentCall( + private class TracingStrategyForComponentCall( fakeExpression: KtReferenceExpression, - reportErrorsOn: KtExpression, - name: Name, - call: Call - ): TracingStrategy { - return object : TracingStrategy by TracingStrategyImpl.create(fakeExpression, call) { - override fun ambiguity(trace: BindingTrace, descriptors: MutableCollection>) { - trace.report(Errors.COMPONENT_FUNCTION_AMBIGUITY.on(reportErrorsOn, name, descriptors)) - } + val reportErrorsOn: KtExpression, + val name: Name, + val call: Call + ) : TracingStrategy by TracingStrategyImpl.create(fakeExpression, call) { - override fun unsafeCall(trace: BindingTrace, type: KotlinType, isCallForImplicitInvoke: Boolean) { - trace.report(Errors.COMPONENT_FUNCTION_ON_NULLABLE.on(reportErrorsOn, name)) - } + override fun ambiguity(trace: BindingTrace, descriptors: Collection>) { + trace.report(Errors.COMPONENT_FUNCTION_AMBIGUITY.on(reportErrorsOn, name, descriptors)) + } - override fun typeInferenceFailed(context: ResolutionContext<*>, inferenceErrorData: InferenceErrorData) { - val diagnostic = AbstractTracingStrategy.typeInferenceFailedDiagnostic(context, inferenceErrorData, reportErrorsOn, call) - if (diagnostic != null) { - context.trace.report(diagnostic) - } + override fun unsafeCall(trace: BindingTrace, type: KotlinType, isCallForImplicitInvoke: Boolean) { + trace.report(Errors.COMPONENT_FUNCTION_ON_NULLABLE.on(reportErrorsOn, name)) + } + + override fun typeInferenceFailed(context: ResolutionContext<*>, inferenceErrorData: InferenceErrorData) { + val diagnostic = AbstractTracingStrategy.typeInferenceFailedDiagnostic(context, inferenceErrorData, reportErrorsOn, call) + if (diagnostic != null) { + context.trace.report(diagnostic) } } } - private fun createTracingStrategyForIteratorCall( + private class TracingStrategyForIteratorCall( fakeExpression: KtReferenceExpression, - reportErrorsOn: KtExpression, - call: Call - ): TracingStrategy { - return object : TracingStrategy by TracingStrategyImpl.create(fakeExpression, call) { - override fun ambiguity(trace: BindingTrace, descriptors: MutableCollection>) { - trace.report(Errors.ITERATOR_AMBIGUITY.on(reportErrorsOn, descriptors)) - } + val reportErrorsOn: KtExpression, + val call: Call + ) : TracingStrategy by TracingStrategyImpl.create(fakeExpression, call) { - override fun unsafeCall(trace: BindingTrace, type: KotlinType, isCallForImplicitInvoke: Boolean) { - trace.report(Errors.ITERATOR_ON_NULLABLE.on(reportErrorsOn)) - } + override fun ambiguity(trace: BindingTrace, descriptors: Collection>) { + trace.report(Errors.ITERATOR_AMBIGUITY.on(reportErrorsOn, descriptors)) + } - override fun typeInferenceFailed(context: ResolutionContext<*>, inferenceErrorData: InferenceErrorData) { - val diagnostic = AbstractTracingStrategy.typeInferenceFailedDiagnostic(context, inferenceErrorData, reportErrorsOn, call) - if (diagnostic != null) { - context.trace.report(diagnostic) - } + override fun unsafeCall(trace: BindingTrace, type: KotlinType, isCallForImplicitInvoke: Boolean) { + trace.report(Errors.ITERATOR_ON_NULLABLE.on(reportErrorsOn)) + } + + override fun typeInferenceFailed(context: ResolutionContext<*>, inferenceErrorData: InferenceErrorData) { + val diagnostic = AbstractTracingStrategy.typeInferenceFailedDiagnostic(context, inferenceErrorData, reportErrorsOn, call) + if (diagnostic != null) { + context.trace.report(diagnostic) } } } @@ -143,8 +141,8 @@ class FakeCallResolver( val call = CallMaker.makeCallWithExpressions(callElement, receiver, null, fakeCalleeExpression, valueArguments) val tracingStrategy = when (realExpression?.callKind) { - FakeCallKind.ITERATOR -> createTracingStrategyForIteratorCall(fakeCalleeExpression, realExpression.expression, call) - FakeCallKind.COMPONENT -> createTracingStrategyForComponentCall(fakeCalleeExpression, realExpression.expression, name, call) + FakeCallKind.ITERATOR -> TracingStrategyForIteratorCall(fakeCalleeExpression, realExpression.expressionToReportErrorsOn, call) + FakeCallKind.COMPONENT -> TracingStrategyForComponentCall(fakeCalleeExpression, realExpression.expressionToReportErrorsOn, name, call) else -> null } @@ -158,5 +156,5 @@ class FakeCallResolver( return Pair(call, results) } - class RealExpression(val expression: KtExpression, val callKind: FakeCallKind) + class RealExpression(val expressionToReportErrorsOn: KtExpression, val callKind: FakeCallKind) }