Alphabetical import ordering enabled by default is a problem in Android Studio/IntelliJ

[dimsuz]

In our project ktlint 0.34.0 now reports a lot of incorrect import ordering, although we use a default import layou of IDE. All our developers have "Optimize imports" enabled by default, but this still creates an order like the following (which seems to be default one of Kotlin IDE plugin):

import ru.example.a
import ru.example.b
import ru.example.c
import javax.inject.Inject

Notice that the last one comes in non alphabetical order.
The unfortunate thing is that this cannot be changed.

Import order editing is there only for Java CodeStyle, kotlin plugin seems not to provide it. Correct me if I'm wrong.

If you think that this is still something that should be default, then please close.

But currently I suspect that many Android Studio/IntelliJ users will be disabling this rule, otherwise they'll have an endless conflict between IDE autoformatter/ktlint.

[shashachu]

@dimsuz as of 0.34.0 you can disable rules via the .editorconfig: https://github.com/pinterest/ktlint#custom-editorconfig-properties

So in this case it would be disabled_rules=import-ordering

[dimsuz]

Thanks for the hint, will do that! Just wanted to report this in case having it as a default is up for review.

[shashachu]

Thanks for the report! Of course anything and everything is up for discussion; I will close this ticket for now but I will keep an eye out for feedback if this rule proves controversial.

[Tapchicoma]

You also can follow this issue from Kotlin side: https://youtrack.jetbrains.com/issue/KT-10974

[dimsuz]

Thanks, voted!

[jrehwaldt]

Adding a property to .editorconfig -- which itself is flagged by yet other linters as invalid -- in order to suppress this lint issue is rather funny. I believe this ticket should be reopened. As it stands, any project with at least a single IntelliJ user (for OpenSource projects I'd argue actually all projects are impacted) has to disable this rule.

[shashachu]

Hi Jan,

Just to get more information, can you give an example of where the IntelliJ optimized imports ends up not in Alphabetical order? I understand it's frustrating to have ktlint disagree with IDEA, it's not clear to me whether the IDEA ordering is a bug or desired behavior. Thanks!

[0legg]

fyi: IDEA puts java/javax imports at the bottom, contrary to ktlint expectations.

[dimsuz]

Yep, I have provided an example of invalid order in the original post, that is where it did go wrong for us.

[shashachu]

Thanks. I just added a comment onto https://youtrack.jetbrains.com/issue/KT-10974 to ask if putting all the java and javax imports at the bottom is a bug or desired behavior. There are a number of instances inside of ktlint rules where we do things to explicitly match IntelliJ's formatting, but if this is a bug, I'm not sure I want to build the same bug into ktlint.

[bhoogter]

It does invalidate the claim on the ktlint README that...

...it makes Intellij IDEA's built-in formatter produce 100% ktlint-compatible code.

If this is 'expected behavior', calling the cli suggested ktlint --apply-to-idea-project becomes mostly useless since a 98% match still means going to the terminal to do ktlint -F, as no one is going alphabetize imports manually (as opposed to other non-automatically fixed issues which can be fixed by user intervention with moderate effort).

[shashachu]

It does invalidate the claim on the ktlint README that...

...it makes Intellij IDEA's built-in formatter produce 100% ktlint-compatible code.

If this is 'expected behavior', calling the cli suggested ktlint --apply-to-idea-project becomes mostly useless since a 98% match still means going to the terminal to do ktlint -F, as no one is going alphabetize imports manually (as opposed to other non-automatically fixed issues which can be fixed by user intervention with moderate effort).

Sure. I understand your frustration, I just want to make sure the IDEA Optimize Imports ordering is not going to change before mimicing the same behavior in ktlint.

[gabrielittner]

Just want to add that if the rule is changed it shouldn't be changed for --android:

Import statements for classes, functions, and properties are grouped together in a single list and ASCII sorted.

https://developer.android.com/kotlin/style-guide#structure

[mkobit]

For what it is worth, the Google Java style guide used to have the java, javax, and some others separate from library imports. Now (I don't remember when it changed), they just have them grouped by non-static and static. From https://google.github.io/styleguide/javaguide.html#s3.3.3-import-ordering-and-spacing:

Imports are ordered as follows:

1. All static imports in a single block.
2. All non-static imports in a single block.

If there are both static and non-static imports, a single blank line separates the two blocks. There are no other blank lines between import statements.

Within each block the imported names appear in ASCII sort order. (Note: this is not the same as the import statements being in ASCII sort order, since '.' sorts before ';'.)

Which the Google Checkstyle stylesheet also uses.

I don't see import order mentioned on https://kotlinlang.org/docs/reference/coding-conventions.html

[JakeWharton]

And Google's Kotlin style guide (not yet public) also matches Java and the Android Kotlin guide in that regard.

[shashachu]

Just want to add that if the rule is changed it shouldn't be changed for --android:

Import statements for classes, functions, and properties are grouped together in a single list and ASCII sorted.

https://developer.android.com/kotlin/style-guide#structure

One thing we're also considering is breaking the android-specific rules into a different ruleset rather than using a flag.

[johntowell]

It does invalidate the claim on the ktlint README that...

...it makes Intellij IDEA's built-in formatter produce 100% ktlint-compatible code.

If this is 'expected behavior', calling the cli suggested ktlint --apply-to-idea-project becomes mostly useless since a 98% match still means going to the terminal to do ktlint -F, as no one is going alphabetize imports manually (as opposed to other non-automatically fixed issues which can be fixed by user intervention with moderate effort).

Sure. I understand your frustration, I just want to make sure the IDEA Optimize Imports ordering is not going to change before mimicing the same behavior in ktlint.

That bug was open in 2016 it looks like, not sure it is going to be resolved quickly. This issue caused quite a bit of headache for us today. Is there any reason not to keep inline with Intellij until if/when it changes?

[VaclavDedik]

Our whole backend team has this problem, so it would really be great if we could turn off this inspection by ktlint by some configuration option (at the very least) :)

[Tapchicoma]

@VaclavDedik check this comment to the way how to disable it: #527 (comment)

[greenkiwi]

We definitely have this issue too.

How painful would it be to add a configuration option for ktlint to handle this case? Even if we have to remove it later once IntelliJ sorts this out.

[dimsuz]

@greenkiwi There's a way to disable this check, see the first comment above.

[greenkiwi]

@dimsuz - We've disabled the check. It would be great to have the option to have it match the IntelliJ order. i.e. still check, just with java/javax at the end.

[gigaSproule]

Any further changes on this? Seems like the kotlin.* imports are being put at the bottom as well.

[liutikas]

The following code block will cause ktlint to report incorrect order

import kotlinx.coroutines.CoroutineDispatcher
import kotlin.coroutines.CoroutineContext

object DirectDispatcher : CoroutineDispatcher() {
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        block.run()
    }
}

This seems to be the default IJ import ordering for koltin and it mismatches ktlint.

[camsteffen]

For those watching at home, this is also fixed on the IDEA side in Kotlin plugin 1.4 - JetBrains/kotlin#3336

[fishy]

I guess this is related, but if it's not, I can create a new issue for it.

When using ktlint 0.40.0, it tries to move my kotlinx.* imports to above both java.* and kotlin.* imports, which looks really weird to me. This is the diff it generated by running ktlint -F:

@@ -15,14 +15,14 @@ import android.service.notification.StatusBarNotification
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.content.edit
-import java.security.SecureRandom
-import java.util.concurrent.locks.ReentrantLock
-import kotlin.concurrent.withLock
-import kotlin.text.Regex
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import java.security.SecureRandom
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+import kotlin.text.Regex

I'm not sure if this is intentional (to match intellij behavior, for example), or a bug.

[romtsn]

@fishy Yes, this is intentional as we are trying to match intellij default behavior, where java, javax and kotlin imports are coming after all others.

[fishy]

@fishy Yes, this is intentional as we are trying to match intellij default behavior, where java, javax and kotlin imports are coming after all others.

Thanks! But maybe kotlinx.* should also be part of that exception list to be put at the bottom? (consider we also have javax.* in the group)

[fishy]

oh never mind just saw that intellij also doesn't add kotlinx there.

[ajans]

I just found out with the "Import Layout" settings in IDEA/AS, you can simply enforce lexicographical import-ordering by removing all entries from "Import Layout" settings for Kotlin aside from "import all other imports" and disable the option "Import aliases separately".

Then IDEA/AS orders imports just the same as ktlint does by default with --android flag (tested with the unofficial ktlint-plugin in AS, which includes ktlint 0.42.1 atm according to changelog).

[svenjacobs]

Although my settings look like this in Preferences / Editor / Code Style / Kotlin / Imports, Android Studio still puts aliased imports first which is a flagged by the import-ordering rule.

I'm unable to get AS to organize imports the way ktlint expects it.

Android Studio Dolphin 2021.3.1
ktlint 0.47.1

[igorwojda]

Ktlint 1.0.1

file .editorconfig

[*.{kt,kts}]
ktlint_standard_import-ordering = disabled

[azaka01]

ktlint_standard_import-ordering = disabled

thank you @igorwojda