mrmans0n / compose-rules Goto Github PK

As reported in #176 (Originally posted by @chrimaeon in #176 (comment)), the fix for running the compose rules with the ktlint-intellij-plugin only partially works. Given code sample below:

import androidx.compose.material3.Text
import androidx.compose.runtime.Composable

@Composable
fun Post() {
    Text("foo")
}

does not show violation below which is shown by Ktlint CLI"

Post.kt:11:5: This @Composable function emits content but doesn't have a modifier parameter.

See https://mrmans0n.github.io/compose-rules/rules/#when-should-i-expose-modifier-parameters for more information. (compose:modifier-missing-check)

Summary error count (descending) by rule:
  compose:modifier-missing-check: 1

Process finished with exit code 1

with ktlint-compose 0.3.9 and intellij-ktlint-plugin 0.20.0

After investigation in ktlint and ktlint-intellij-plugin, I have found the cause of the problem. Like in #176 the cause is the embedded kotlin compiler which conflicts with packages provided by Intellij IDEA itself. In the ktlint-intellij-plugin those problems are resolved with relocating packages.

I have tried to relocate the packages in ktlint to prevent that third party supplier of rules are not affected by this but it didn't work out as expected. For now, I see no other solution than that each third party supplier of rules applies relocation of packages similar as is done in ktlint-intellij-plugin. For compose rules that would mean that configuration below has to be added to build file of ktlint-rules:

shadowJar {
    // Relocate packages that may conflict with ktlint-intellij-plugin. The rule set won't work when relocations below
    // are not kept in sync with https://github.com/nbadal/ktlint-intellij-plugin/blob/main/lib/build.gradle.kts
    relocate("org.jetbrains.concurrency", "shadow.org.jetbrains.concurrency")
    relocate("org.jetbrains.kotlin.psi.KtPsiFactory", "shadow.org.jetbrains.kotlin.psi.KtPsiFactory")
    relocate("org.jetbrains.kotlin.psi.psiUtil", "shadow.org.jetbrains.kotlin.psi.psiUtil")
    relocate("org.jetbrains.org", "shadow.org.jetbrains.org")
}

On my local machine, I have build the compose rules for ktlint with changes above. Both ktlint CLI and ktlint-intelli-plugin now report the violation as requested by OP.

Hello
Thank you for maintaining this library !

Whenever used with the detekt extension, all works as expected. However, when using integrating detekt as gradle task here this error shows up.

detekt 'compose' property is misspelled or does not exist.

how can this be fixed ?

Two issues observed in JakeWharton/mosaic#267

• If a modifier param doesn't have a default, it shouldn't be treated as special in the mandatory/optional order list.
• The trailing lambda should take into account typealiases to functions / fun interfaces that are defined in the same file (as we can't have type resolution).
• As a stretch goal, there should be a new config parameter to allowlist specific types so they are treated as lambdas in this case too.

Modifier reused rule only checks reuse for single modifier parameter. Instances of more than one modifier reused are missed.

This rule is reporting a violation for the following Composable's expanded parameter:

@Composable
fun ExpandableText(
    text: String,
    modifier: Modifier = Modifier,
    collapsedMaxLines: Int = 3,
    color: Color = Color.Unspecified,
    expanded: MutableState<Boolean> = rememberSaveable { mutableStateOf(false) },
    fontSize: TextUnit = TextUnit.Unspecified,
    fontStyle: FontStyle? = null,
    fontWeight: FontWeight? = null,
    fontFamily: FontFamily? = null,
    letterSpacing: TextUnit = TextUnit.Unspecified,
    textDecoration: TextDecoration? = null,
    textAlign: TextAlign? = null,
    lineHeight: TextUnit = TextUnit.Unspecified,
    overflow: TextOverflow = TextOverflow.Clip,
    softWrap: Boolean = true,
    minLines: Int = 1,
    style: TextStyle = LocalTextStyle.current,
    placeholder: Boolean = false,
) {
[...]

The parameter expanded: MutableState<Boolean> is using an androidx.compose.runtime.MutableState and I don't think should trigger the error

Using mutable objects as state in Compose will cause your users to see incorrect or stale data in your app.
Mutable objects that are not observable, such as ArrayList<T> or a mutable data class, cannot be observed by Compose to trigger recomposition when they change.

An example of the official Material3 Using MutableState as parameter: https://github.com/androidx/androidx/blob/72d507d1723a212997afe83bd7779f7524ed2bff/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/Menu.kt#L188

I can understand that this doesn't follow the principle of "Hoist all the things", but the error states that MutableState is not observable and "will cause your users to see incorrect or stale data" which, afaik, is not true:

 * A mutable value holder where reads to the [value] property during the execution of a [Composable]
 * function, the current [RecomposeScope] will be subscribed to changes of that value. When the
 * [value] property is written to and changed, a recomposition of any subscribed [RecomposeScope]s
 * will be scheduled. If [value] is written to with the same value, no recompositions will be
 * scheduled.

Can the rule be split between real unobservable objects like ArrayList<T> and ViewModel and the observable one like MutableState or have an optional configuration parameter to ignore observable objects?

io.nlopez.compose.rules:detekt:0.3.15

Fail if we use Material 3 in the project and try to make custom ripple effect

androidx.compose.material.ripple.rememberRipple

@Composable
fun TestRipple(
    selected: Boolean,
    onClick: () -> Unit,
    enabled: Boolean = true
) {
    Box(
        modifier = Modifier
            .selectable(
                selected = selected,
                onClick = onClick,
                enabled = enabled,
                interactionSource = remember { MutableInteractionSource() },
                indication = rememberRipple(bounded = false),
                role = Role.Tab,
            )
            .fillMaxHeight()
    ) {
        Text(text = "Select")
    }
}

looks like will be change in Compose 1.7.0
https://developer.android.com/develop/ui/compose/touch-input/user-interactions/migrate-indication-ripple

I'm seeing an issue where a trailing function that is nullable, without a default param, it does not pass the ComposableParamOrder lint check.

I get this error:

Warning  (detekt) ComposableParamOrder
    Parameters in a composable function should be ordered following this
    pattern: params without defaults, modifiers, params with defaults and
    optionally, a trailing function that might not have a default param.
...

I don't want to post my exact source code, so here's something very similar:

The following composable declaration will show the error.

@Composable
fun SomeView(
    paramWithoutDefault: Boolean,
    modifier: Modifier = Modifier,
    paramWithDefault: Int = 5,
    trailingFunction: (() -> Unit)?,
) {}

What I would expect is this to pass the lint check, since the warning states the allowed order is

1. params without defaults
2. modifiers
3. params with defaults
4. optionally, a trailing function that might not have a default param.

(4) should allow a trailing function that doesn't have a default param, regardless of its nullability.

Describe the bug

Looks like the ModifierMissing rule is not able to detect multipreview usage, so it flags those previews as missing modifiers. If there's a technical issue with detecting it, maybe we can at least have an exclusion by function name. Maybe by regex or even just assume that previews end with "Preview".

The ModifierComposable rule says that you should use Modifier.composed instead of a Composable function. However the compose-api-guidelines say that Modifier.composed is now discouraged.

Seems I can't disable modifier-missing-check for whole project, should we add something like compose_check_modifiers_for_visibility = none or compose_check_modifiers_for_visibility = disabled to support this?

There is an error with this repository's Renovate configuration that needs to be fixed. As a precaution, Renovate will stop PRs until it is resolved.

Location: renovate.json
Error type: The renovate configuration file contains some invalid settings
Message: Invalid configuration option: includeForks

In nbadal/ktlint-intellij-plugin#425 it was reported that the compose rules are not working in the new ktlint-intellij-plugin while they do work in Ktlint CLI.

Post.kt:

import androidx.compose.material3.Text
import androidx.compose.runtime.Composable

@Composable
fun Post() {
    Text("foo")
}

.editorconfig:

root = true
[*.{kt,kts}]
ij_kotlin_imports_layout = *,java.**,javax.**,kotlin.**,^
ij_kotlin_allow_trailing_comma = false
ij_kotlin_allow_trailing_comma_on_call_site = false
ktlint_function_naming_ignore_when_annotated_with=Composable

Output with ktlint CLI 1.1.0:

/opt/homebrew/bin/ktlint -F -R <path>/scripts/ktlint-compose-0.3.8-all.jar .../Post.kt
<path>/Post.kt:11:5: This @Composable function emits content but doesn't have a modifier parameter.

See https://mrmans0n.github.io/compose-rules/rules/#when-should-i-expose-modifier-parameters for more information. (compose:modifier-missing-check)

Summary error count (descending) by rule:
  compose:modifier-missing-check: 1

Process finished with exit code 1

The lint violation is however not reported by the ktlint-intellij-plugin.

After investigation, I have found that the usages of KtStubElementTypes in KtlintRule is the most likely cause of the problem.

        when (node.elementType) {
            KtStubElementTypes.FILE -> {
                psi.attach(config)
                visitFile(psi as KtFile, autoCorrect, emit.toEmitter())
            }

            KtStubElementTypes.CLASS -> visitClass(psi as KtClass, autoCorrect, emit.toEmitter())
            KtStubElementTypes.FUNCTION -> {
                val function = psi as KtFunction
                val emitter = emit.toEmitter()
                visitFunction(function, autoCorrect, emitter)
                if (function.isComposable) {
                    visitComposable(function, autoCorrect, emitter)
                }
            }
        }

Here the node.elementType is checked against KtStubElementTypes instead of using ElementType. This might also be used in other classes.

To proof that above assumption is the cause of the problem, I have build a new simple rule in a new custom ruleset in ktlint:

class NoFooFun :
    Rule(
        ruleId = RuleId("$CUSTOM_RULE_SET_ID:no-foo-fun"),
        about =
            About(
                maintainer = "Your name",
                repositoryUrl = "https://github.com/your/project/",
                issueTrackerUrl = "https://github.com/your/project/issues",
            ),
    ) {
    override fun beforeVisitChildNodes(
        node: ASTNode,
        autoCorrect: Boolean,
        emit: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit,
    ) {
        // Compose ruleset uses KtStubElementTypes in KtlintRule class to match element types. This works fine when rules are used with
        // ktlint CLI as the embeddable kotlin compiler is used.
        if (node.elementType == KtStubElementTypes.FUNCTION) {
            node
                .findChildByType(ElementType.IDENTIFIER)
                ?.takeIf { it.text == "foo" }
                ?.let {
                    emit(node.startOffset, "Unexpected fun foo (via KtStubElementTypes.FUNCTION)", false)
                }
        }

        // However, when the ruleset is used in combination with the ktlint-intelli-plugin, the KtStubElementTypes are no longer recognized.
        // Most likely this is caused by interoperability problems between the embedded kotlin compiler in the KtLintRuleEngine versus the
        // Kotlin compiler in IntelliJ IDEA.
        if (node.elementType == ElementType.FUN) {
            node
                .findChildByType(ElementType.IDENTIFIER)
                ?.takeIf { it.text == "foo" }
                ?.let {
                    emit(node.startOffset, "Unexpected fun foo (via elementType.FUN)", false)
                }
        }
    }
}

Given code sample below:

fun foo() {
    // do something
}

and ktlint CLI 1.1.0 this produces:

$ ktlint-1.1.0 --relative -R ~/Downloads/ktlint-custom-ruleset-example-1.1.0.jar
15:21:12.813 [main] INFO com.pinterest.ktlint.cli.internal.KtlintCommandLine -- Enable default patterns [**/*.kt, **/*.kts]
src/main/kotlin/Foo.kt:1:1: Unexpected fun foo (via KtStubElementTypes.FUNCTION) (custom-rule-set-id:no-foo-fun)
src/main/kotlin/Foo.kt:1:1: Unexpected fun foo (via elementType.FUN) (custom-rule-set-id:no-foo-fun)

Summary error count (descending) by rule:
  custom-rule-set-id:no-foo-fun: 2

The problem is reported twice, as was to be expected. The embeddable kotlin compiler in Ktlint CLI can match the element type of the node both to 'ElementType.FUNandKtStubElementTypes.FUNCTION`.

When using the same ruleset jar in ktlint-intellij-plugin, following problems are reported:

As you can see, the problem is now only reported as it matches with ElementType.FUN. I am not 100% sure about the reason, but I believe that the KtStubElementTypes are not compatible with the IDEA kotlin compiler.

Can you provide a snapshot version of the compose ruleset that uses ElementType instead of KtStubElementTypes so that we can verify whether this resolves the problem?

Currently ktlint is fixed to 0.50.0 in this project's config. Bumping it to the latest yields a ton of new linting errors, that will need to be fixed.

When specified in config.yml it seems to have no effect:

  ModifierMissing:
    active: true
    checkModifiersForVisibility: public_and_internal

@Composable
internal fun GreetingNoModifier(name: String) {
    Text(
        text = "Hello $name!",
    )
}

yields no extra tech debt 😢

I have a working test project if you need it.

Let's say we have the following function:

@Composable
fun ScreenRoute(viewModel: ScreenViewModel)

although there is no default value, it is still correct. Here the rule works fine. Then we use it for example from the navigation declaration like this:

composable(destination = Destination.ScreenRoute) {
  ScreenRoute(
    viewModel = hiltViewModel()
  )
}

Here, too, everything works correctly. But then we decide to use assistedfactory to add parameters to the viewmodel and change the code like this:

composable(destination = Destination.ScreenRoute) {
  val viewModel = hiltViewModel(
       creationCallback = { factory: ScreenViewModel.Factory ->
           factory.create(
               parameter = 5,
               parameter2 = null
           )
       }
   )
   ScreenRoute(
       viewModel = viewModel
   )
}

This is where the rule sounds the alarm, although everything still remains correct. Let's go further and explicitly declare the type of the viewModel variable:

composable(destination = Destination.ScreenRoute) {
  val viewModel: ScreenViewModel = hiltViewModel(
       creationCallback = { factory: ScreenViewModel.Factory ->
           factory.create(
               parameter = 5,
               parameter2 = null
           )
       }
   )
   ScreenRoute(
       viewModel = viewModel
   )
}

Here the rule finally loses its mind and it puts the variable with the viewmodel into the parameter of the function in which all the screens are located:

Navigation(
  ...
  navController: NavHostController = rememberNavController()
  **<here>**
) {
NavHost(
    navController = navController,
    startDestination = startDestination
) {
    composable(destination = Destination.ScreenRoute) {...}
    composable(destination = Destination.Screen1Route) {...}
  }
}

kotlin = "1.9.23"
compose = "1.6.4"
ktlint = "12.1.0"
ktlintComposeRules = "0.3.12"

As you can see in the official document of Custom Modifiers, the lint for not using @Composable for custom modifiers is now removed:

Note: In previous versions of Compose, we recommended against this approach and suggested using composed {} instead via a lint rule. Now that composed {} is not recommended, the lint rule has been removed.

So I think it is better to also remove it from this ruleset.

Reference of the rule in the repository's website

Reference of the rule in the repository

Sometimes there can be a false positives when dealing with content emitters. We should add a way to add exemptions to emitsContent in the configuration.

ViewModelForwarding rule misses the case of scope function use.
For example the code below wouldn't be caught:

@Composable
fun SomeComposable(viewModel: MyViewModel) {
  with(viewModel) {
      AnotherComposable(this)
  }
}

I am working on upgrading the ktlint-intelli-plugin to Ktlint 1.x. In this issue it is mentioned that the plugin does not work with the compose ruleset. When I use the ktlint-0.3.2.jar artifact, I get error java.lang.NoClassDefFoundError: io/nlopez/rules/core/ComposeKtVisitor.

According to the documentation I should use ktlint-compose-<VERSION>-all.jar which I can not find on Maven. Is the documentation outdated or is the artifact somehow not published?

Compose rules doesn't work in ktlint android studio plugin.

Compose rule version jar: v0.3.13
Android studio version: Android Studio Hedgehog | 2023.1.1
Ktlint plugin version: 0.21.0

@composable
fun TestCompose() {
}

Error:
Function name should start with a lowercase letter (except factory methods) and use camel case (standard:function-naming)

compose:multiple-emitters-check failed to detekt issues, in following code.

private fun Content(title: String? = null, subtitle: String? = null) {
    title?.let {
        Text(text = it)
    }

    subtitle?.let {
        Text(text = it)
    }
}

I didn't double check this, since I'm short on time. I only noticed, that our CI didn't complain.

Library version: 0.3.3

Hello, I am using Detekt plugin on Android Studio. To apply this plugin, I downloaded its .jar file and attached in under Settings -> Tools -> detekt -> Plugin JAR(s), however, after applying all rules to detekt.yaml, the compiler still shows the errors. How to solve this issue? Thanks.

The documentation is being uploaded but the link is all wrong. I might have changed this at some point years ago but can't seem to find the place in the docs to update this.

Anyway, https://mrmans0n.github.io/compose-rules should point to this project docs.

Even with PreviewPublic rule, in large codebase, it's still easy to import wrong Composable function because of unclear naming. Having such code:

@Preview
@Composable
internal fun MyText() {
    MyText("Sample text")
}

It's not immediately clear that this is just a preview composable. I think it would be good to have a rule which enforces preview composables naming with Preview as suffix, similar to PreviewNaming rule (initially I thought that was the purpose of this rule 🙈). Wdyt? :)

I have this composable:

@Composable
internal fun MyComposable(
    param: Param,
    modifier: Modifier = Modifier,
    onClick1: () -> Unit,
    onClick2: () -> Unit,
) {

but the ktlint rule throws this:

Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param.
Current params are: [param: Param, modifier: Modifier = Modifier, onClick1: () -> Unit, onClick2: () -> Unit] but should be [param: Param, onClick1: () -> Unit, modifier: Modifier = Modifier, onClick2: () -> Unit].

Not sure why it is complaining about the modifier position, I think is an error, it also happens with others @composables

Few things give Compose away more than this.
Pay attention to the corners when you click on the Share and Copy buttons.

In Compose, it's very easy to make clickability that doesn't match the radius of the rounding.
Just mix up the modifiers, it happens every day.

Can you, please, add a rule to prevent such ordering?

As mentioned in #129, v0.3.4 has a bug with CompositionLocalAllowlist rule that it ignores white listed CompositionLocals added to allowedCompositionLocals.

Repro example project: https://github.com/vector-im/element-x-android/pull/1906/files (thanks /cc @julioromano): Build failure log

Will try to create a minimal repro if above is not enough.

Trying to apply rule set with kotlinter (latest 3.13.0).

While running check I'm getting following errors:

lint worker execution error
java.lang.NoClassDefFoundError: Could not initialize class org.jmailen.gradle.kotlinter.support.RuleSetsKt
	at org.jmailen.gradle.kotlinter.tasks.lint.LintWorkerAction.execute(LintWorkerAction.kt:43)
...

This does not happen while using non-forked original classpath "com.twitter.compose.rules:ktlint:<version>"

Konsist seems to become more and more popular, are you considering adding support for it?

I added these rules to Mosaic mostly for the function naming rule, but I'm getting errors about missing Modifier parameters. Now, Mosaic does have a Modifier type now, but that wasn't always the case. And it certainly isn't the case that other Compose-based projects will have such a type. In Redwood we are actively planning on eliminating our Modifier type because the semantics are not the same as in Compose UI. Once that happens our node-emitting functions will never be able to comply with this rule.

The presence of a Modifier type is certainly common across multiple node types, but it's not fundamentally intrinsic to Compose. What should the behavior of this rule be in the larger non-Compose UI, Compose-based ecosystem?

Maybe it could hardcode a list of well-known Modifier types (Compose UI + Glance) which are detected on the classpath to enable the rule. And then perhaps a configuration option could be exposed for cases like Mosaic where we can specify the fully-qualified type name of our Modifier. Plus, in the future case of Redwood, this would allow our non-"Modifier"-named Modifier-like type to participate in this rule's validation.

I'm not sure if this is an issue and I'm also not sure what exactly is happening here:

Renovate updated my project from 0.1.11 to 0.1.12 and it fails with:

• What went wrong:
  'boolean org.jetbrains.kotlin.com.intellij.openapi.util.SystemInfo.isJavaVersionAtLeast(int, int, int)'

https://github.com/PaulWoitaschek/Voice/actions/runs/5486717033/jobs/9997172727?pr=2032

If my guess is correct, we can only use kotlin 1.9 in compose rules after gradle supports it.

I have the next code in my project:

fun interface MyInterface { @Composable operator fun invoke(param: MyParam) }

The compose_naming_check rule is complaining :

Composable functions that return Unit should start with an uppercase letter.
They are considered declarative entities that can be either present or absent in a composition and therefore follow the naming rules for classes.

I'm wondering if operator fun should be whitelisted from this specific rule as it doesn't make sense to make them be uppercase

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

This repository currently has no open or pending branches.

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

As seen in slackhq/compose-lints#129 (comment), multiple content emitter detection shouldn't be forced if there is a context receiver, as we can't know for sure it's still a violation, and we want to err on the side of not surfacing false positives.

There might be valid patterns where you want to forward a VM-like class. Usually this could be worked around by using an optional param with viewModel() as a default value and not passing the VM from stateful-parent to stateful-child directly. However, this only works if there is a way to acquire the VMs via a factory, which might not be the case (cough cough Compose multiplatform).

We should allow the allowlisting of Composables that match some given regexes.

NVD is failing cause its confusing the core-ktlint package with the ktlint-core package of the 0.30.0 version of the pinterest ktlint library https://github.com/pinterest/ktlint/tree/0.30.0/ktlint-core

OWASP-Dependency-Check is striking your library cause of that.

This is the issue your Library is now being reference to: https://nvd.nist.gov/vuln/detail/CVE-2019-1010260

In section https://mrmans0n.github.io/compose-rules/rules/#when-should-i-expose-modifier-parameters

the following link is broken

More info: Always provide a Modifier parameter

I think it should point to https://chrisbanes.me/posts/always-provide-a-modifier/

The same check to compose:naming-check is already available in Compose Runtime here, and can be suppressed with @Suppress("ComposableNaming").
The compose:naming-check rule should check for that suppression so that we don't need to suppress the same check with two different names.

Morning!

There is a typo in https://github.com/mrmans0n/compose-rules/releases/tag/v0.3.0:

If you are using Detekt, you'll need to change the PreviewAnnotationNaming in your detekt.yml config to be PreviewAnnotationNaming.

Should be:

If you are using Detekt, you'll need to change the PreviewNaming in your detekt.yml config to be PreviewAnnotationNaming.

If someone can edit the release description to avoid confusing the users, that would be awesome! Thanks.

(change on our side: element-hq/element-x-android@fb87c77)

The idea is to align naming of preview composable functions in unified format.
we already have PreviewAnnotationNaming and PreviewPublic.

Propose:
name: ComposePreviewNaming
logic: composable preview function should require Preview postfix

Didn't find any official docs, but Google follow this name convention: https://developer.android.com/develop/ui/compose/tooling/previews

valid code

@Preview
@Composable
private fun SectionCounterPreview() {
    // code
}

invalid

@Preview
@Composable
private fun SectionCounter() {
    // code
}

@Preview
@Composable
private fun PreviewSectionCounter() {
    // code
}

Execution failed for task ':app:detekt'.
> Could not resolve all files for configuration ':app:detektPlugins'.
   > Could not resolve org.jetbrains.kotlin:kotlin-compiler-embeddable:{strictly 1.9.0}.
     Required by:
         project :app > io.gitlab.arturbosch.detekt:detekt-cli:1.23.1
      > Cannot find a version of 'org.jetbrains.kotlin:kotlin-compiler-embeddable' that satisfies the version constraints:
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:{strictly 1.9.0}'
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-parser:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0'
           Dependency path 'My Application:app:unspecified' --> 'io.nlopez.compose.rules:detekt:0.3.0' (runtimeElements) --> 'io.nlopez.compose.rules:core-common:0.3.0' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.10'
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-tooling:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-api:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0'
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-parser:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-psi-utils:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0'

   > Could not resolve org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0.
     Required by:
         project :app > io.gitlab.arturbosch.detekt:detekt-cli:1.23.1 > io.gitlab.arturbosch.detekt:detekt-parser:1.23.1
         project :app > io.gitlab.arturbosch.detekt:detekt-cli:1.23.1 > io.gitlab.arturbosch.detekt:detekt-tooling:1.23.1 > io.gitlab.arturbosch.detekt:detekt-api:1.23.1
         project :app > io.gitlab.arturbosch.detekt:detekt-cli:1.23.1 > io.gitlab.arturbosch.detekt:detekt-parser:1.23.1 > io.gitlab.arturbosch.detekt:detekt-psi-utils:1.23.1
      > Cannot find a version of 'org.jetbrains.kotlin:kotlin-compiler-embeddable' that satisfies the version constraints:
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:{strictly 1.9.0}'
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-parser:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0'
           Dependency path 'My Application:app:unspecified' --> 'io.nlopez.compose.rules:detekt:0.3.0' (runtimeElements) --> 'io.nlopez.compose.rules:core-common:0.3.0' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.10'
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-tooling:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-api:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0'
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-parser:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-psi-utils:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0'

   > Could not resolve org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.10.
     Required by:
         project :app > io.nlopez.compose.rules:detekt:0.3.0 > io.nlopez.compose.rules:core-common:0.3.0
      > Cannot find a version of 'org.jetbrains.kotlin:kotlin-compiler-embeddable' that satisfies the version constraints:
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:{strictly 1.9.0}'
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-parser:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0'
           Dependency path 'My Application:app:unspecified' --> 'io.nlopez.compose.rules:detekt:0.3.0' (runtimeElements) --> 'io.nlopez.compose.rules:core-common:0.3.0' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.10'
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-tooling:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-api:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0'
           Dependency path 'My Application:app:unspecified' --> 'io.gitlab.arturbosch.detekt:detekt-cli:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-parser:1.23.1' (runtimeElements) --> 'io.gitlab.arturbosch.detekt:detekt-psi-utils:1.23.1' (runtimeElements) --> 'org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0'

An exclusion is needed in order to avoid it:

    detektPlugins("io.gitlab.arturbosch.detekt:detekt-cli:1.23.1")
    detektPlugins("io.gitlab.arturbosch.detekt:detekt-formatting:1.23.1")
    detektPlugins("io.nlopez.compose.rules:detekt:0.3.0") {
        exclude(group = "org.jetbrains.kotlin", module = "kotlin-compiler-embeddable")
    }

I have a test project showing this issue if you need it.

Hi, thanks for the fork.
Everything works as expected except rule PreviewPublic.

For example this code block.
Expected behaviour: fail detekt due to this function public.

@Preview(showBackground = true)
@Composable
fun FilledIconButtonPreview() {
    FilledIconButton(
        onClick = {},
        imageVector = Icons.Default.Done
    )
}

When using something like this as custom multi-preview definitions, probably the check should not trigger a warning.

@Preview(device = Devices.PIXEL_2, name = "PIXEL_2")
@Preview(device = Devices.NEXUS_7_2013, name = "NEXUS_7_2013")
annotation class DevicesPreview

In Compose UI 1.6.0 Google will introduce predefined multi-preview annotations. See commit

The annotation class names are PreviewScreenSizes, PreviewFontScale, PreviewLightDark and PreviewDynamicColors, so always having Preview as the prefix.

Currently your rule enforces Preview as the suffix in custom preview annotations we declare in our code.
So should a change in your rule be considered to be aligned with this naming scheme?

I would like to know the reasoning behind Modifiers being only mandatory in public functions.

Additionally, I would like to request a way to change this setting if possible.

https://mrmans0n.github.io/compose-rules/rules/#when-should-i-expose-modifier-parameters

The changelog of ktlint says:

https://github.com/pinterest/ktlint/releases/tag/0.49.0

WARNING: This version of KtLint contains a number of breaking changes in KtLint CLI and KtLint API. If you are using KtLint with custom ruleset jars or custom reporter jars, then those need to be upgraded before you can use them with this version of ktlint. Please contact the maintainers of those jars and ask them to upgrade a.s.a.p.

It would be great if you could update it :) Also I'm wondering why renovate didn't pick it up.

Would it make sense to also include some compose rules from appKODE?

https://github.com/appKODE/detekt-rules-compose

We can minify rule set jars using R8, it will significantly decrease the size.

I'm working on a similar thing at pinterest/ktlint#2347.

I'm getting a false positive for ModifierNotUsedAtRoot with 0.2.0 because MaterialTheme doesn't have a Modifier parameter.

@Composable
private fun SampleCard(
  modifier: Modifier = Modifier,
  content: @Composable BoxScope.() -> Unit
) {
  MaterialTheme(
    colorScheme = darkColorScheme()
  ) {
    Box(
      modifier = modifier
        .fillMaxSize()
        .background(
          color = MaterialTheme.colorScheme.background
        )
    ) { ... }
  }
}

I'm wondering if there was a chance to add some config for the modifier-missing-check similarly like compose_allowed_composition_locals.

We have quite few composable functions/screens for manual UI testing, which have arg less signature

@Composable
fun TestXYZScreen() { ... }

In this case, our preferences is to follow simple arg less composable function.
Unfortunately internal modifier doesn't necessary work well in kotlin multiplatform setup.

So I was wondering for something like following to add to .editorconfig,
compose_allowed_no_modifier_functions = regex1, regex2
where I could simply pass a regexp to have easier control over the rule instead of having explicit @Suppress or passing unused Modifier for this usecase