A Java 9 issue related to reflection. I ran java -jar .../detekt-cli.jar -p . against a simple Kotlin project, using Java 9 (build 9-ea+159):

Caused by: java.lang.reflect.InaccessibleObjectException: Unable to make private jdk.internal.reflect.ConstructorAccessor java.lang.reflect.Constructor.acquireConstructorAccessor() accessible: module java.base does not "opens java.lang.reflect" to unnamed module @34c4973
        at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(Unknown Source)
        at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(Unknown Source)
        at java.base/java.lang.reflect.Method.checkCanSetAccessible(Unknown Source)
        at java.base/java.lang.reflect.Method.setAccessible(Unknown Source)
        at com.intellij.util.ReflectionUtil.findMethod(ReflectionUtil.java:265)
        at com.intellij.util.ReflectionUtil.getDeclaredMethod(ReflectionUtil.java:279)
        at com.intellij.util.ReflectionUtil.<clinit>(ReflectionUtil.java:422)
        ... 14 more

• McCabe over classes, packages, modules
• New Finding implementation
• Can be implemented with UserData of Psi

Before M3 I think the kotlin compiler throw a strange exception when running as a gradle plugin...

Support is needed for GSK (Gradle Script Kotlin) which is used by some Kotlin projects, and there are some which provide support for it (eg Spek). Currently GSK is at version 0.9.1 which means now would be a good opportunity to start supporting GSK before it reaches a stable version.

If you miss a certain detector/feature, please let me now!

• extensions

In tests, I like to have very specific method names that are human readable.

For example:

fun `With input X, the output should be Y`()

However, this is not valid in Android apps.

As such, it would be nice if I could specify a different configuration for the tests in my project.

Format:

inline fun <T> to(block: () -> T): Try<T> {
    try {
        return Try(block.invoke(), null)
    } catch (any: Throwable) {
        return Try(null, any)
    }
}

to

inline fun <T> to(block: () -> T) =
    try {
        Try(block.invoke(), null)
    } catch (any: Throwable) {
        Try(null, any)
    }

It would be awesome if the analysis could be done in the background directly in IDEA in order to see/fix every problem before even compiling anything!

• like gradle-daemon or kotinc-daemon
• faster analysis, jvm warmup on start only

It'd be cool if the console output could be optimized a bit. For instance given the following line:

ComplexCondition - 5/3 - [timesFor] - Line/Column=(44,11) - Path=main/java/io/sunnyspots/android/io/model/Time.kt

it would be beneficial to change a few things:

• include the project dir in the file (in my case app/src/)
• remove the Path= so that the file will be clickable in iTerm2 for instance
• Make use of the line number and column

I'd propose to change it to the following

-ComplexCondition - 5/3 - [timesFor] - Line/Column=(44,11) - Path=main/java/io/sunnyspots/android/io/model/Time.kt
+ComplexCondition - 5/3 - [timesFor] at app/src/main/java/io/sunnyspots/android/io/model/Time.kt:44:11

Hi there! I have a couple ideas for rules that would help my team a lot, and hopefully would help others, too.

Always use expression syntax in functions when possible

Suppose you have

fun foo(): String {
  return ""
}

If there's only one statement and the method has a non-void return value, it should always be turned into the equivalent expression version:

fun foo(): String = ""

While just a style issue, this is something we end up calling out in our code reviews constantly and...we'd like to not have to do that 😉

Remainder was split off into #36.

Check if private fields, methods, parameter and locale variables are unused.

Idea:

1. Visit KtFile and store names of fields and methods in a Map<String, Int>
2. Visit methods look for references, increment reference map
3. If field/method have same name as local or parameter, check positions.

The default patterns are pretty good, but users should be able to specify their own regular expressions.

pro:

• get fixes asap from ktlint
• more rules?

neg:

• different kotlinc versions
• two engines -> same work twice? -> shortcuts? invoke ktlint
• detekt additional formatting rules split

I would like to be able to enforce a maximum line length on the files being linted

• Move some codeSmell rules to complexity ruleset
• Introduce TooManyFunctions rule
• Introduce ConditionalComplexity rule

https://github.com/arturbosch/detekt/blob/master/detekt-formatting/src/main/kotlin/io/gitlab/arturbosch/detekt/formatting/Indentation.kt seems to assume every line will be indented by some multiple of 4 spaces.

In Android Studio, I have these options checked:

The result is code that looks like:

fun example(arg0: String, arg1: String,
                      arg2: String) {

This is not a multiple of 4 spaces.

In general, I want to ensure that all code is indented properly, but it's not always going to be a multiple of 4 spaces.

Hey,

I have encountered this problem and cannot find a way to fix it.
style:
active: true
WildcardImport:
active: true
NamingConventionViolation:
active: true
variablePattern: '^()?[a-z$][a-zA-Z$0-9]*$'
constantPattern: '^([A-Z0-9]|serialVersionUID)$'
methodPattern: '^[a-z$][a-zA-Z$0-9]$'
classPattern: '[A-Z$][a-zA-Z0-9$]*'

Even if i delete all the patterns, i get the NamingConventionViolation in my report, when i try to modify these patterns, no changes are detected in process. The only thing that works for me is activate or deactivate.

Please publish the artifacts straight to JCenter instead of "misusing" Bintray as a Maven repository. That would simplify the setup for most users as JCenter usually is already added as a repository.

Problems:

• migrate configurations kotlin to kotlinCompile
• hamKrest is on 1.0 and uses moved reflection packages

Right now I'm seeing two configuration files in the project. #1 & #2.

I'm not sure now whether there are any more rules or not that I could make use of. Plus whether some rules might have some more attributes that can be configured or not.

Is something like an aggregated configuration file with proper documentation planned?

• how many smells lead to a hotspot?
• how many hotspot to show in the report? just one, the biggest?

There is an unpublished dependency on smell-baseline-format in detekt. As Java9 does not preload the module java.xml.bind, every start of detekt needs an additional parameter which can confuse users.

There are three possibilities:

1. Publish the dependency as it is now to jcenter (it just works)
2. Use another preloaded xml module/rewrite and publish to jcenter
3. Rewrite as 2. and integrate the format into detekt

I use SonarQube for all of my projects (it is a free service for open source projects). It would be great to have a plugin, which can be used to show the results of a static code analysis of Kotlin code done by detekt in SonarQube (I use the sonarqube-gradle-plugin).

Split off from #35.

Expression-syntax line breaks

Another more nuanced (and admittedly, somewhat arbitrary) rule is the following:
When using expression syntax:

1. If the expression is a one-liner, the = should be on the same line as the expression, and both should be on the line following the method prototype.
2. Otherwise, the = should be right after the method prototype, and the rest of the expression should be on the following lines.

Example:

fun foo(): String
    = " Hello World ".trim()

fun bar(): String =
    foo()
        .baz()
        .bat()

Ideas:

• like the yaml configuration options but as a kotlin script
• allow to write output/console reports
• allow to define rules