From be11c97f855f8315ee7b57515e9f9546cb21ffeb Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Wed, 10 Aug 2022 09:19:53 -0400 Subject: [PATCH 01/13] add `UnnecessaryNotNullCheck` rule --- .../main/resources/default-detekt-config.yml | 2 + .../detekt/rules/bugs/PotentialBugProvider.kt | 1 + .../rules/bugs/UnnecessaryNotNullCheck.kt | 61 +++++++++++++++++++ 3 files changed, 64 insertions(+) create mode 100644 detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt diff --git a/detekt-core/src/main/resources/default-detekt-config.yml b/detekt-core/src/main/resources/default-detekt-config.yml index 59de0ada0e4..85f6a37b1d1 100644 --- a/detekt-core/src/main/resources/default-detekt-config.yml +++ b/detekt-core/src/main/resources/default-detekt-config.yml @@ -472,6 +472,8 @@ potential-bugs: active: false UnnecessaryNotNullOperator: active: true + UnnecessaryNotNullCheck: + active: true UnnecessarySafeCall: active: true UnreachableCatchBlock: diff --git a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/PotentialBugProvider.kt b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/PotentialBugProvider.kt index 87481632ea4..c6041d3fae6 100644 --- a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/PotentialBugProvider.kt +++ b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/PotentialBugProvider.kt @@ -39,6 +39,7 @@ class PotentialBugProvider : DefaultRuleSetProvider { RedundantElseInWhen(config), UnconditionalJumpStatementInLoop(config), UnnecessaryNotNullOperator(config), + UnnecessaryNotNullCheck(config), UnnecessarySafeCall(config), UnreachableCode(config), UnsafeCallOnNullableType(config), diff --git a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt new file mode 100644 index 00000000000..7d040a6c1d1 --- /dev/null +++ b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt @@ -0,0 +1,61 @@ +package io.gitlab.arturbosch.detekt.rules.bugs + +import io.gitlab.arturbosch.detekt.api.CodeSmell +import io.gitlab.arturbosch.detekt.api.Debt +import io.gitlab.arturbosch.detekt.api.Entity +import io.gitlab.arturbosch.detekt.api.Issue +import io.gitlab.arturbosch.detekt.api.Rule +import io.gitlab.arturbosch.detekt.api.Severity +import io.gitlab.arturbosch.detekt.api.internal.RequiresTypeResolution +import org.jetbrains.kotlin.psi.KtCallExpression +import org.jetbrains.kotlin.psi.KtExpression +import org.jetbrains.kotlin.psi.psiUtil.getCallNameExpression +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.calls.util.getType +import org.jetbrains.kotlin.types.typeUtil.TypeNullability +import org.jetbrains.kotlin.types.typeUtil.nullability + +/** + * Reports unnecessary not-null checks with `requireNotNull` or `checkNotNull` that can be removed by the user. + * + * + * var string = "foo" + * println(requireNotNull(string)) + * + * + * + * var string : String? = "foo" + * println(requireNotNull(string)) + * + */ +@RequiresTypeResolution +class UnnecessaryNotNullCheck(config: Config = Config.empty) : Rule(config) { + + override val issue = Issue( + "UnnecessaryNotNullOperator", + Severity.Defect, + "Unnecessary not-null check detected.", + Debt.FIVE_MINS, + ) + + override fun visitCallExpression(expression: KtCallExpression) { + super.visitCallExpression(expression) + + if (bindingContext == BindingContext.EMPTY) return + + val callName = expression.getCallNameExpression()?.text + if (callName == "requireNotNull" || callName == "checkNotNull") { + val type = (expression.valueArguments[0].lastChild as KtExpression).getType(bindingContext) + if (type?.nullability() == TypeNullability.NOT_NULL) { + report( + CodeSmell( + issue = issue, + entity = Entity.from(expression), + message = "${expression.text} contains an unnecessary `$callName`", + ) + ) + } + } + } + +} From 6485665f05d5033fa42c3cf6bccfe5c3edbef0cb Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Wed, 10 Aug 2022 09:48:02 -0400 Subject: [PATCH 02/13] change issue name --- .../arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt index 7d040a6c1d1..f1ae14362af 100644 --- a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt +++ b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt @@ -1,6 +1,7 @@ package io.gitlab.arturbosch.detekt.rules.bugs import io.gitlab.arturbosch.detekt.api.CodeSmell +import io.gitlab.arturbosch.detekt.api.Config import io.gitlab.arturbosch.detekt.api.Debt import io.gitlab.arturbosch.detekt.api.Entity import io.gitlab.arturbosch.detekt.api.Issue @@ -32,7 +33,7 @@ import org.jetbrains.kotlin.types.typeUtil.nullability class UnnecessaryNotNullCheck(config: Config = Config.empty) : Rule(config) { override val issue = Issue( - "UnnecessaryNotNullOperator", + "UnnecessaryNotNullCheck", Severity.Defect, "Unnecessary not-null check detected.", Debt.FIVE_MINS, From 19a3173e99ec27c78937538c4794253a3c5d1dd9 Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Thu, 11 Aug 2022 09:51:55 -0400 Subject: [PATCH 03/13] add tests --- .../rules/bugs/UnnecessaryNotNullCheckSpec.kt | 131 ++++++++++++++++++ 1 file changed, 131 insertions(+) create mode 100644 detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt diff --git a/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt b/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt new file mode 100644 index 00000000000..2f8ebb3974d --- /dev/null +++ b/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt @@ -0,0 +1,131 @@ +package io.gitlab.arturbosch.detekt.rules.bugs + +import io.gitlab.arturbosch.detekt.rules.KotlinCoreEnvironmentTest +import io.gitlab.arturbosch.detekt.test.assertThat +import io.gitlab.arturbosch.detekt.test.lintWithContext +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test + +@KotlinCoreEnvironmentTest +class UnnecessaryNotNullCheckSpec(private val env: KotlinCoreEnvironment) { + private val subject = UnnecessaryNotNullCheck() + + @Nested + inner class `check unnecessary not null checks` { + + @Test + fun shouldDetectNotNullCallOnVariable() { + val code = """ + val x = 5 + val y = requireNotNull(x) + """.trimIndent() + val findings = subject.lintWithContext(env, code) + assertThat(findings).hasSize(1) + assertThat(findings).hasTextLocations(18 to 35) + } + + @Test + fun shouldDetectNotNullCallOnVariableUsingCheckNotNull() { + val code = """ + val x = 5 + val y = checkNotNull(x) + """.trimIndent() + val findings = subject.lintWithContext(env, code) + assertThat(findings).hasSize(1) + assertThat(findings).hasTextLocations(18 to 33) + } + + @Test + fun shouldDetectNotNullCallOnFunctionReturn() { + val code = """ + fun foo(): Int { + return 5 + } + fun bar() { + requireNotNull(foo()) + } + """.trimIndent() + val findings = subject.lintWithContext(env, code) + assertThat(findings).hasSize(1) + assertThat(findings).hasTextLocations(48 to 69) + } + + @Test + fun shouldDetectWhenCallingPrimitiveJavaMethod() { + val code = """ + fun foo() { + requireNotNull(System.currentTimeMillis()) + } + """.trimIndent() + val findings = subject.lintWithContext(env, code) + assertThat(findings).hasSize(1) + assertThat(findings).hasTextLocations(16 to 58) + } + + } + + @Nested + inner class `check valid not null check usage` { + + @Test + fun shouldIgnoreNotNullCallOnNullableVariableWithValue() { + val code = """ + val x: Int? = 5 + val y = requireNotNull(x) + """.trimIndent() + val findings = subject.lintWithContext(env, code) + assertThat(findings).isEmpty() + } + + @Test + fun shouldIgnoreNotNullCallOnNullableVariableWithNull() { + val code = """ + val x: Int? = null + val y = requireNotNull(x) + """.trimIndent() + val findings = subject.lintWithContext(env, code) + assertThat(findings).isEmpty() + } + + @Test + fun shouldIgnoreNotNullCallOnNullableFunctionReturnWithValue() { + val code = """ + fun foo(): Int? { + return 5 + } + fun bar() { + requireNotNull(foo()) + } + """.trimIndent() + val findings = subject.lintWithContext(env, code) + assertThat(findings).isEmpty() + } + + @Test + fun shouldIgnoreNotNullCallOnNullableFunctionReturnWithNull() { + val code = """ + fun foo(): Int? { + return null + } + fun bar() { + requireNotNull(foo()) + } + """.trimIndent() + val findings = subject.lintWithContext(env, code) + assertThat(findings).isEmpty() + } + + @Test + fun shouldIgnoreWhenCallingObjectJavaMethod() { + val code = """ + fun foo() { + requireNotNull(System.getLogger()) + } + """.trimIndent() + val findings = subject.lintWithContext(env, code) + assertThat(findings).isEmpty() + } + + } +} From 174c564786e8e5a5ce7a7aea1b72c529999ba407 Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Thu, 11 Aug 2022 10:07:27 -0400 Subject: [PATCH 04/13] change config order --- detekt-core/src/main/resources/default-detekt-config.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/detekt-core/src/main/resources/default-detekt-config.yml b/detekt-core/src/main/resources/default-detekt-config.yml index 85f6a37b1d1..465ba16471c 100644 --- a/detekt-core/src/main/resources/default-detekt-config.yml +++ b/detekt-core/src/main/resources/default-detekt-config.yml @@ -470,9 +470,9 @@ potential-bugs: active: true UnconditionalJumpStatementInLoop: active: false - UnnecessaryNotNullOperator: - active: true UnnecessaryNotNullCheck: + active: false + UnnecessaryNotNullOperator: active: true UnnecessarySafeCall: active: true From 26156a02990192668dfba81872567e9d9ab80012 Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Thu, 11 Aug 2022 10:11:37 -0400 Subject: [PATCH 05/13] remove unexpected blank lines --- .../arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt | 1 - .../arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt | 2 -- 2 files changed, 3 deletions(-) diff --git a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt index f1ae14362af..63f9f0abe6d 100644 --- a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt +++ b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt @@ -58,5 +58,4 @@ class UnnecessaryNotNullCheck(config: Config = Config.empty) : Rule(config) { } } } - } diff --git a/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt b/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt index 2f8ebb3974d..24a675803bb 100644 --- a/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt +++ b/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt @@ -62,7 +62,6 @@ class UnnecessaryNotNullCheckSpec(private val env: KotlinCoreEnvironment) { assertThat(findings).hasSize(1) assertThat(findings).hasTextLocations(16 to 58) } - } @Nested @@ -126,6 +125,5 @@ class UnnecessaryNotNullCheckSpec(private val env: KotlinCoreEnvironment) { val findings = subject.lintWithContext(env, code) assertThat(findings).isEmpty() } - } } From 5411caf0d93d51bd0accf86249d950804c6335ff Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Thu, 11 Aug 2022 10:17:14 -0400 Subject: [PATCH 06/13] add backticks for expression text --- .../arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt index 63f9f0abe6d..06035a7198b 100644 --- a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt +++ b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt @@ -52,7 +52,7 @@ class UnnecessaryNotNullCheck(config: Config = Config.empty) : Rule(config) { CodeSmell( issue = issue, entity = Entity.from(expression), - message = "${expression.text} contains an unnecessary `$callName`", + message = "`${expression.text}` contains an unnecessary `$callName`", ) ) } From 20a70f0f1977cf47689807c40b782b92f914043c Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Mon, 15 Aug 2022 09:23:44 -0400 Subject: [PATCH 07/13] use fully qualified name --- .../detekt/rules/bugs/UnnecessaryNotNullCheck.kt | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt index 06035a7198b..83e1ea38934 100644 --- a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt +++ b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt @@ -8,6 +8,8 @@ import io.gitlab.arturbosch.detekt.api.Issue import io.gitlab.arturbosch.detekt.api.Rule import io.gitlab.arturbosch.detekt.api.Severity import io.gitlab.arturbosch.detekt.api.internal.RequiresTypeResolution +import io.gitlab.arturbosch.detekt.rules.isCalling +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtCallExpression import org.jetbrains.kotlin.psi.KtExpression import org.jetbrains.kotlin.psi.psiUtil.getCallNameExpression @@ -44,18 +46,23 @@ class UnnecessaryNotNullCheck(config: Config = Config.empty) : Rule(config) { if (bindingContext == BindingContext.EMPTY) return - val callName = expression.getCallNameExpression()?.text - if (callName == "requireNotNull" || callName == "checkNotNull") { + if (expression.isCalling(requireNotNullFunctionFqName, bindingContext) || expression.isCalling( + checkNotNullFunctionFqName, bindingContext)) { val type = (expression.valueArguments[0].lastChild as KtExpression).getType(bindingContext) if (type?.nullability() == TypeNullability.NOT_NULL) { report( CodeSmell( issue = issue, entity = Entity.from(expression), - message = "`${expression.text}` contains an unnecessary `$callName`", + message = "`${expression.text}` contains an unnecessary `${expression.getCallNameExpression()?.text}`", ) ) } } } + + companion object { + private val requireNotNullFunctionFqName = FqName("kotlin.requireNotNull") + private val checkNotNullFunctionFqName = FqName("kotlin.checkNotNull") + } } From d1f0d6a36955583c1301e66f06e16b67edfdaf16 Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Mon, 15 Aug 2022 09:35:15 -0400 Subject: [PATCH 08/13] update description --- .../arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt index 83e1ea38934..e2c4f15ba6c 100644 --- a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt +++ b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt @@ -37,7 +37,7 @@ class UnnecessaryNotNullCheck(config: Config = Config.empty) : Rule(config) { override val issue = Issue( "UnnecessaryNotNullCheck", Severity.Defect, - "Unnecessary not-null check detected.", + "Remove unnecessary not-null checks on non-null types.", Debt.FIVE_MINS, ) From 48cf4a8c3c2adb4f493ad67bba50cc5c1d9741aa Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Mon, 15 Aug 2022 09:45:56 -0400 Subject: [PATCH 09/13] change message --- .../detekt/rules/bugs/UnnecessaryNotNullCheck.kt | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt index e2c4f15ba6c..8bc853d9d3a 100644 --- a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt +++ b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt @@ -48,13 +48,14 @@ class UnnecessaryNotNullCheck(config: Config = Config.empty) : Rule(config) { if (expression.isCalling(requireNotNullFunctionFqName, bindingContext) || expression.isCalling( checkNotNullFunctionFqName, bindingContext)) { - val type = (expression.valueArguments[0].lastChild as KtExpression).getType(bindingContext) - if (type?.nullability() == TypeNullability.NOT_NULL) { + val argument = expression.valueArguments[0].lastChild as KtExpression + if (argument.getType(bindingContext)?.nullability() == TypeNullability.NOT_NULL) { + val callName = expression.getCallNameExpression()?.text report( CodeSmell( issue = issue, entity = Entity.from(expression), - message = "`${expression.text}` contains an unnecessary `${expression.getCallNameExpression()?.text}`", + message = "Using `$callName` on non-null `${argument.text}` is unnecessary", ) ) } From d241d2ef9175edbe09ba2766a25719e56b4b0a03 Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Mon, 15 Aug 2022 10:38:24 -0400 Subject: [PATCH 10/13] add tests for generics --- .../rules/bugs/UnnecessaryNotNullCheckSpec.kt | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt b/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt index 24a675803bb..819dcc05b65 100644 --- a/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt +++ b/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt @@ -51,6 +51,22 @@ class UnnecessaryNotNullCheckSpec(private val env: KotlinCoreEnvironment) { assertThat(findings).hasTextLocations(48 to 69) } + @Test + fun shouldDetectWhenCallingDefinitelyNonNullableGenericFunction() { + val code = """ + fun foo(x: T & Any): T & Any { + return x + } + fun bar() { + requireNotNull(foo(5)) + } + """.trimIndent() + val findings = subject.lintWithContext(env, code) + println(findings) + assertThat(findings).hasSize(1) + assertThat(findings).hasTextLocations(66 to 88) + } + @Test fun shouldDetectWhenCallingPrimitiveJavaMethod() { val code = """ @@ -115,6 +131,20 @@ class UnnecessaryNotNullCheckSpec(private val env: KotlinCoreEnvironment) { assertThat(findings).isEmpty() } + @Test + fun shouldIgnoreWhenCallingNullableGenericFunction() { + val code = """ + fun foo(x: T): T { + return x + } + fun bar() { + requireNotNull(foo(null)) + } + """.trimIndent() + val findings = subject.lintWithContext(env, code) + assertThat(findings).isEmpty() + } + @Test fun shouldIgnoreWhenCallingObjectJavaMethod() { val code = """ From 017780568d19bf7d063e7368d7c3c1f18fd12ce3 Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Mon, 15 Aug 2022 12:23:36 -0400 Subject: [PATCH 11/13] fix detekt --- .../arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt index 8bc853d9d3a..1c7b7dafa6e 100644 --- a/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt +++ b/detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheck.kt @@ -46,8 +46,9 @@ class UnnecessaryNotNullCheck(config: Config = Config.empty) : Rule(config) { if (bindingContext == BindingContext.EMPTY) return - if (expression.isCalling(requireNotNullFunctionFqName, bindingContext) || expression.isCalling( - checkNotNullFunctionFqName, bindingContext)) { + if (expression.isCalling(requireNotNullFunctionFqName, bindingContext) || + expression.isCalling(checkNotNullFunctionFqName, bindingContext) + ) { val argument = expression.valueArguments[0].lastChild as KtExpression if (argument.getType(bindingContext)?.nullability() == TypeNullability.NOT_NULL) { val callName = expression.getCallNameExpression()?.text From d647c39b8d044358c3823b39ab7ebda09cd45f08 Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Mon, 15 Aug 2022 13:54:13 -0400 Subject: [PATCH 12/13] remove debug printing --- .../arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt | 1 - 1 file changed, 1 deletion(-) diff --git a/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt b/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt index 819dcc05b65..89538a79824 100644 --- a/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt +++ b/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt @@ -62,7 +62,6 @@ class UnnecessaryNotNullCheckSpec(private val env: KotlinCoreEnvironment) { } """.trimIndent() val findings = subject.lintWithContext(env, code) - println(findings) assertThat(findings).hasSize(1) assertThat(findings).hasTextLocations(66 to 88) } From eb2aa3dea3d4693a4e0d60abd8561775ed184e36 Mon Sep 17 00:00:00 2001 From: Mark Vadeika Date: Mon, 15 Aug 2022 13:58:46 -0400 Subject: [PATCH 13/13] use value instead of `null` to be more clear about types --- .../arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt b/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt index 89538a79824..a6b2b351964 100644 --- a/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt +++ b/detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/UnnecessaryNotNullCheckSpec.kt @@ -137,7 +137,7 @@ class UnnecessaryNotNullCheckSpec(private val env: KotlinCoreEnvironment) { return x } fun bar() { - requireNotNull(foo(null)) + requireNotNull(foo(5)) } """.trimIndent() val findings = subject.lintWithContext(env, code)