I’m getting a huge number of compilation errors when I run

./gradlew detektMain

on my Android project. Including this… 😂

error: 'trySend(E): ChannelResult<Unit>' is only available since Kotlin 1.4.30 and cannot be used in Kotlin 1.5

These errors don’t come up when compiling normally, what’s happening here?

Hi! I have a multi-module gradle project, which has a Sonar intergration, and I wish to use Detekt metrics inside Sonar. Here is my root gradle build file sonar entry. I have setup sources and test for all the subprojects.

property("sonar.sources", "src/main")
      property("sonar.tests", "src/test")

But when I run 

gradle sonarqube

 task, I keep getting errors like:

No input file found for /Users/gopala.akshintala/code-clones/my-github/vader-root/vader/build/generated/sources/delombok/java/main/org/revcloud/vader/runner/Utils.kt. No detekt issues will be imported on this file.

 And I don’t see any detekt related errors. Note: I am using lombok for some modules, so I even tried this:

property(
        "sonar.sources",
        the<SourceSetContainer>()["main"].allJava.srcDirs.filter { it.exists() }.joinToString(",")
      )
      property(
        "sonar.tests",
        the<SourceSetContainer>()["test"].allJava.srcDirs.filter { it.exists() }.joinToString(",")
      )

but I keep getting the same error with file path being different (pointing to generated, so I guess this is not lombok specific)

No input file found for /Users/gopala.akshintala/code-clones/my-github/vader-root/vader/build/generated/sources/delombok/java/main/org/revcloud/vader/runner/Utils.kt. No detekt issues will be imported on this file.

Please help!

Hi did someone work with spotless. I'm not sure if I should go with spotless or detekt (both have ktlint integrated, while spotless has also ktfmt and diktat on board). Can someone give me an advice?

I have a function (

KtNamedFunction

) and I want to know if the returning type is Unit or not with type solving. I'm using this:

function.bodyExpression.getResolvedCall(bindingContext)?.resultingDescriptor?.returnType?.isUnit()

but I get null for functions like this:

fun asdf() = 5

. And if I use this:

function.getType(bindingContext)?.fqNameOrNull()?.shortName()?.let { it.toString() == "Unit" }

get

null

for

fun asdf() {}

.

I created something: https://github.com/BraisGabin/detekt-junit-rules It's a rule set to avoid common mistakes while using JUnit. Right now it just have one rule but it's an important one: did you know that if your

@Test

function doesn't return

Unit

JUnit will not execute it? But, no one returns something in those functions, right? Well... if you uses coroutines and follow this pattern in your tests:

@Test fun foo() = runBlocking { ... }

your tests are not executed at all. Give the custom rule a try if you want 🙂. All feedback is more than welcome.

I am observing following error after updating gradle in the project to 7.X

A problem occurred evaluating script.
> Failed to apply plugin 'io.gitlab.arturbosch.detekt'.
   > Cannot run Project.afterEvaluate(Action) when the project is already evaluated.

The thing is I have multiple modules and I am applying detekt to all of them just by

allprojects {
  apply from: "$rootDir/detekt.gradle"
}

in the root project. This was working so far. Is there a remedy for that or it needs to be fixed in Detekt gradle plugin?

Does anyone here know if it's at all possible to suppress rules everywhere that a specific annotation (not

Suppress

) is present? And if so, how?

Two "issues" I added detect to my android project via the plugins block in my root build.gradle. 1. Now I try to run

./gradlew detektMain

, but I get an error:

Task 'detektMain' not found in root project 'rollertoaster'.

2. If I run ./gradlew detekt, I get a success message in 1s, but I don't think detekt actually analyzed my code.

The following Kotlin source sets were configured but not added to any Kotlin compilation:
 * androidAndroidTestRelease
 * androidTestFixtures
 * androidTestFixturesDebug
 * androidTestFixturesRelease
You can add a source set to a target's compilation by connecting it with the compilation's default source set using 'dependsOn'.
See <https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#connecting-source-sets>

BUILD SUCCESSFUL in 1s

3. I can't add detekt into spotless right? I use spotless in order to run ktfmt, so being able to add detekt into spotless would be cool. Can I get help on those three?

I have trouble with non-working excludes, I've found several related answers in this chat, but they all are fixed by including

withType

in

subprojects

while I already have this:

subprojects {
  apply plugin: "io.gitlab.arturbosch.detekt"
  detekt { ... }

  tasks.withType(io.gitlab.arturbosch.detekt.Detekt).configureEach {
    exclude("**/entity/generated/**")
  }
}

And yet the file with path like this:

module/src/main/kotlin/data/network/entity/generated/AmountModel.kt:34:3

ends up being checked by detekt. Any hints on what I did wrong? Version is

1.18.1

https://twitter.com/tagir_valeev/status/1441415679534583808?s=19 interesting. We should take a look to that code and see if we can port it. It would be even better if we could create a generic adapter so we could run intellij rules as we run ktlint rules.

Now that Java 17 was released we are going to support 3 LTS versions. It's time to think if we can drop Java 8 support. I would like to here from users that need this project to still support Java8 and why. For that reason I created this discussion on the repo: https://github.com/detekt/detekt/discussions/4130

Hi, I’m having trouble making detect autoformat too long lines. Here’s my config:

build:
  maxIssues: 0
  excludeCorrectable: false

config:
  validation: true
  warningsAsErrors: false

processors:
  active: true

comments:
  active: true
  UndocumentedPublicClass:
    active: true
    excludes: [ '**/test/**', '**/integrationTest/**', '**/systemTest/**', '*Test' ]
    searchInNestedClass: true
    searchInInnerClass: true
    searchInInnerObject: true
    searchInInnerInterface: true
  UndocumentedPublicFunction:
    active: true
    excludes: [ '**/test/**', '**/integrationTest/**', '**/systemTest/**', '*Test' ]
  UndocumentedPublicProperty:
    active: true
    excludes: [ '**/test/**', '**/integrationTest/**', '**/systemTest/**', '*Test' ]

formatting:
  active: true
  autoCorrect: true
  MaximumLineLength:
    active: true
    autoCorrect: true
    maxLineLength: 120
    ignoreBackTickedIdentifier: true

configuration:

detekt {
    toolVersion = "1.18.1"
    config = files("config/detekt/detekt.yml")
    buildUponDefaultConfig = true
    autoCorrect = true
    debug = true
}

I have a line longer than 120 chars and doesn’t get formatted correctly when I run

gradle detekt

. What do I miss here?

Running

gradle check

used to run all the necessary detekt tasks for me

detektMetadata

,

detektJvmMain

etc...). It seems to no longer be doing that. How can I get the behavior back?

In our CI pipeline we run

detekt

,

detektMain

and then

detektTest

so we get type resolution running across both main and test source sets. However when we do this the report files seem to overwrite each other, and only one is left at the end (seems to be a random one). Any idea how we can keep all the report files - or merge them as we go along?

I had detekt-rules as a gradle sub-project, and then I moved them to a separate jar. This jar is published in our local maven repository and added as

detektPlugins("path:to:artifact")

. Gradle sync is finished OK, jar is downloaded and used, but when I run the 'detekt' task it prints an error that

detekt-config.yml

contains an unknown property

myrulesetname

. I have rechecked that this published jar has

services/path.to.ruleset.Ruleset

file. What can go wrong? Do I need to add something else to this jar?

So we’ve been killed by Qodana 😅 ?

Hello #detekt community. A question for Gradle users. I just posted it here, on GitHub discussions https://github.com/detekt/detekt/discussions/4196. How do you decouple a failing detekt task from

gradle build

task graph? I am not ready to fix all my existing code base right now to make this step pass. I would like to exclude it from gradle build and run on demand only, by calling it explicitly with

gradle detekt

Hi folks, I am seeing a weird thing, running

1.18.1

but switched to

1.17..1

and saw the same thing. I am seeing a weird thing, where when I get my Detekt issues down to 0, the configuration file seems to get ignored... I mean if I have at least 1 error, I will see it, but and as soon as I fix it - so I am down to 0 issues, Detekt seems to ignore my config file (and I see ALL the issues I have carefully Suppressed) My detekt config:

apply plugin: "io.gitlab.arturbosch.detekt"

detekt {
    toolVersion = detekt_version
    buildUponDefaultConfig = true
    autoCorrect = true
    source = files("$projectDir")
    config = files("$projectDir/analysis/detekt/detekt.yml")
    parallel = true

    reports {
        html.enabled = true
        xml.enabled = false
        txt.enabled = false
    }
}

Is there some default value I need to set to change this functionality? I feel like this must be something I have configured wrong, since I can see this in

1.17.1

and

1.18.1

(so it is not likely a bug, or this would be a bigger deal.

I'm testing using

detektMain

on my project. One of my library modules generates code in

build/generated/myapp/kotlin

which is added as a source set to main like so:

extensions.getByType<LibraryExtension>().sourceSets {
  named("main") {
    java {
      srcDir(layout.buildDirectory.file("generated/myapp/kotlin"))
    }
  }
}

However, I don't want detekt to look at generated files. How can I prevent that?

I'm trying out detekt 1.19.0-RC1 and can't get

ignoreAnnotated

working on

FunctionNaming

rule with

Composable

annotation. I've tried config:

FunctionNaming:
    active: true
    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
    functionPattern: '([a-z][a-zA-Z0-9]*)|(`.*`)'
    excludeClassPattern: '$^'
    ignoreOverridden: true
    ignoreAnnotated:
      - 'Composable'

Also tried setting it to full

androidx.compose.runtime.Composable

, but I'm still getting reports on all Composable functions Am I configuring it wrong?

During refactoring I often do something like:

// before
val itemId = 3
onClick = { someListener(itemId) }
// after
onClick = { someListener() }
// OR
onClick = { itemId -> someListener(itemId) }

in the latter cases this can be simplified to (no extra wrapping lambda):

onClick = someListener

I'm about to try to write a custom check for this, but I thought maybe there already is one?

I have a convention plugin published with is using a default config for Detekt. I am using this plugin in a lot of repositories. The problem is I want to add default rules to it, without having to add them to the yaml of each repository which is using this convention plugin. Ideally should be great that there is a way to create rules as dependencies and add them to Detekt without having to specify them in the yaml. Potentially public API:

detekt {
    rules {
        detektRule("com.example.rules:custom-rule-one:1.0.0")
        // alternatives: `implementation`, `add`, etc.
        // automatically applied without indicating it in the yaml
    }
}

Another solution can be merging yaml files via adding them to resource folders or something so, but I prefer the previous API.

I see from the docs that detekt can validate formatting via ktlint, but can it also format files with it?

We'd like to enable

NamedArguments

with

threshold=1

only for

Composable

functions, is there some analog of

ignoreAnnotated

which is in reverse: something like

onlyAnnotated

?

Detekt swears in the Multiplatform project. At the same time, there are no such errors in IDEA. What to do about it?Detekt swears in the Multiplatform project. At the same time, there are no such errors in IDEA. What to do about it? https://github.com/itbasis/kochange/runs/4278481352?check_suite_focus=true#step:4:42

I've been using detekt

1.19.0-RC1

on my Android project. The type resolution tasks cannot find Android classes so they report many false positives. For example

val sensorManager: SensorManager = context.getSystemService() ?: return null
    val sensor = sensorManager.getDefaultSensor(sensorType) ?: return null

Reports unreachable code for everything after the first

?: return null

because it cannot find the type of

context

and seems to assume that it always returns null. See

UnsafeCast

warnings also when checking and then casting for classes that extend

View

. Is there any configuration that I can do to make detekt find the Android classes during type resolution?

I'm generating baseline for whole project using this custom task

task detektProjectBaseline(type: DetektCreateBaselineTask,  group: "detekt") {
    description = "Overrides current baseline."
    buildUponDefaultConfig = false
    ignoreFailures.set(true)
    parallel.set(true)
    setSource(files(rootDir))
    config.setFrom(files("$rootDir/quality/detekt/detekt-config.yml"))
    baseline.set(file("$rootDir/quality/detekt/baseline.xml"))
    include("**/*.kt")
    exclude("**/res/**", "**/build/**", "**/*.kts", "**/test/**", "**/androidTest/**")
    classpath.setFrom(project.configurations.getByName("detekt"))
}

and I have another task which runs on files that I'm passing through

-PinputFiles

gradle param

task detektChangedFiles(type: Detekt, group: "detekt") {
    description = "Runs over changed files."
    buildUponDefaultConfig = false
    ignoreFailures = false
    parallel = true
    if (project.hasProperty("inputFiles")) {
        setSource(files(inputFiles.split('\n')))
    }
    config.setFrom(file("$rootDir/quality/detekt/detekt-config.yml"))
    baseline.set(file("$rootDir/quality/detekt/baseline.xml"))
    include("**/*.kt")
    exclude("**/res/**", "**/build/**", "**/*.kts", "**/test/**", "**/androidTest/**")
    classpath.setFrom(project.configurations.getByName("detekt"))
    reports {
        xml {
            enabled = true
            destination = file("build/reports/detekt.xml")
        }
        html {
            enabled = true
            destination = file("build/reports/detekt.html")
        }
    }
}

The problem is that after running detektChangedFiles I'm getting issues like UnnecessaryLet that my baseline doesn't contain for that file. Seems baseline generation task ignores some rules

Hello there, we use the limit of 60 loc per method as a

Detekt

rule

LongMethod:
    active: true
    threshold: 60

but we find it too small for

@Composable

functions. Is there a way to exclude composables from this limit, something like

ignoreAnnotated

in

LongParameterList

?

Hey, one quick question should detekt run formatting automatically if i have autoCorrect = true when i run gradlew detekt?