From 240311d9c7e62923d9c9898b82f32bb969f5d184 Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Fri, 26 Jun 2020 18:23:21 +0300 Subject: [PATCH] Minor. Reformat JavaNullabilityChecker --- .../jvm/checkers/JavaNullabilityChecker.kt | 69 ++++++++++--------- 1 file changed, 38 insertions(+), 31 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityChecker.kt index fda7841ad04..491d1468edb 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityChecker.kt @@ -41,10 +41,10 @@ class JavaNullabilityChecker : AdditionalTypeChecker { override fun checkType(expression: KtExpression, expressionType: KotlinType, expressionTypeWithSmartCast: KotlinType, c: ResolutionContext<*>) { doCheckType( - expressionType, - c.expectedType, - { c.dataFlowValueFactory.createDataFlowValue(expression, expressionType, c) } , - c.dataFlowInfo + expressionType, + c.expectedType, + { c.dataFlowValueFactory.createDataFlowValue(expression, expressionType, c) }, + c.dataFlowInfo ) { expectedType, actualType -> c.trace.report(ErrorsJvm.NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS.on(expression, expectedType, actualType)) } @@ -59,7 +59,8 @@ class JavaNullabilityChecker : AdditionalTypeChecker { val enumClassDescriptor = WhenChecker.getClassDescriptorOfTypeIfEnum(type) ?: return val context = c.trace.bindingContext if (WhenChecker.getEnumMissingCases(expression, context, enumClassDescriptor).isEmpty() - && !WhenChecker.containsNullCase(expression, context)) { + && !WhenChecker.containsNullCase(expression, context) + ) { val subjectDataFlowValue = c.dataFlowValueFactory.createDataFlowValue(subjectExpression, type, c) val dataFlowInfo = c.trace[BindingContext.EXPRESSION_TYPE_INFO, subjectExpression]?.dataFlowInfo if (dataFlowInfo != null && !dataFlowInfo.getStableNullability(subjectDataFlowValue).canBeNull()) { @@ -75,9 +76,9 @@ class JavaNullabilityChecker : AdditionalTypeChecker { val baseExpression = expression.baseExpression ?: return val baseExpressionType = c.trace.getType(baseExpression) ?: return doIfNotNull( - baseExpressionType, - { c.dataFlowValueFactory.createDataFlowValue(baseExpression, baseExpressionType, c) }, - c + baseExpressionType, + { c.dataFlowValueFactory.createDataFlowValue(baseExpression, baseExpressionType, c) }, + c ) { c.trace.report(Errors.UNNECESSARY_NOT_NULL_ASSERTION.on(expression.operationReference, baseExpressionType)) } @@ -90,11 +91,11 @@ class JavaNullabilityChecker : AdditionalTypeChecker { KtTokens.EXCLEQEQEQ -> { if (expression.left != null && expression.right != null) { SenselessComparisonChecker.checkSenselessComparisonWithNull( - expression, expression.left!!, expression.right!!, c, - { c.trace.getType(it) }, - { value -> - doIfNotNull(value.type, { value }, c) { Nullability.NOT_NULL } ?: Nullability.UNKNOWN - } + expression, expression.left!!, expression.right!!, c, + { c.trace.getType(it) }, + { value -> + doIfNotNull(value.type, { value }, c) { Nullability.NOT_NULL } ?: Nullability.UNKNOWN + } ) } } @@ -102,7 +103,12 @@ class JavaNullabilityChecker : AdditionalTypeChecker { } } - override fun checkReceiver(receiverParameter: ReceiverParameterDescriptor, receiverArgument: ReceiverValue, safeAccess: Boolean, c: CallResolutionContext<*>) { + override fun checkReceiver( + receiverParameter: ReceiverParameterDescriptor, + receiverArgument: ReceiverValue, + safeAccess: Boolean, + c: CallResolutionContext<*> + ) { val dataFlowValue by lazy(LazyThreadSafetyMode.NONE) { c.dataFlowValueFactory.createDataFlowValue(receiverArgument, c) } @@ -117,10 +123,10 @@ class JavaNullabilityChecker : AdditionalTypeChecker { } doCheckType( - receiverArgument.type, - receiverParameter.type, - { dataFlowValue }, - c.dataFlowInfo + receiverArgument.type, + receiverParameter.type, + { dataFlowValue }, + c.dataFlowInfo ) { expectedType, actualType -> val receiverExpression = (receiverArgument as? ExpressionReceiver)?.expression @@ -134,11 +140,11 @@ class JavaNullabilityChecker : AdditionalTypeChecker { } private fun doCheckType( - expressionType: KotlinType, - expectedType: KotlinType, - dataFlowValue: () -> DataFlowValue, - dataFlowInfo: DataFlowInfo, - reportWarning: (expectedType: KotlinType, actualType: KotlinType) -> Unit + expressionType: KotlinType, + expectedType: KotlinType, + dataFlowValue: () -> DataFlowValue, + dataFlowInfo: DataFlowInfo, + reportWarning: (expectedType: KotlinType, actualType: KotlinType) -> Unit ) { if (TypeUtils.noExpectedType(expectedType)) { return @@ -157,15 +163,16 @@ class JavaNullabilityChecker : AdditionalTypeChecker { } private fun doIfNotNull( - type: KotlinType, - dataFlowValue: () -> DataFlowValue, - c: ResolutionContext<*>, - body: () -> T + type: KotlinType, + dataFlowValue: () -> DataFlowValue, + c: ResolutionContext<*>, + body: () -> T ) = if (type.mustNotBeNull()?.isFromJava == true && - c.dataFlowInfo.getStableNullability(dataFlowValue()).canBeNull()) - body() - else - null + c.dataFlowInfo.getStableNullability(dataFlowValue()).canBeNull() + ) + body() + else + null private fun KotlinType.mayBeNull(): EnhancedNullabilityInfo? = when { !isError && !isFlexible() && TypeUtils.acceptsNullable(this) -> enhancementFromKotlin()