Make interactiveFormat actually work

ktlint-api-consumer/src/test/kotlin/com/pinterest/ktlint/api/consumer/KtLintRuleEngineTest.kt

@@ -7,6 +7,7 @@ import com.pinterest.ktlint.rule.engine.api.KtLintRuleEngine
 import com.pinterest.ktlint.rule.engine.api.LintError
 import com.pinterest.ktlint.rule.engine.core.api.ElementType
 import com.pinterest.ktlint.rule.engine.core.api.Rule
+import com.pinterest.ktlint.rule.engine.core.api.RuleAutocorrectApproveHandler
 import com.pinterest.ktlint.rule.engine.core.api.RuleId
 import com.pinterest.ktlint.rule.engine.core.api.RuleProvider
 import com.pinterest.ktlint.rule.engine.core.api.editorconfig.EXPERIMENTAL_RULES_EXECUTION_PROPERTY
@@ -313,6 +314,42 @@ class KtLintRuleEngineTest {
                 """.trimIndent(),
             )
         }
+
+        @Test
+        fun `Given a kotlin code snippet that does contain multiple indentation errors then only format the lint error at specific offset and message`() {
+            val ktLintRuleEngine =
+                KtLintRuleEngine(
+                    ruleProviders =
+                        setOf(
+                            RuleProvider { IndentationRule() },
+                        ),
+                    fileSystem = ktlintTestFileSystem.fileSystem,
+                )
+
+            val originalCode =
+                """
+                fun main() {
+                println("Hello world!")
+                println("Hello world!")
+                println("Hello world!")
+                }
+                """.trimIndent()
+            val actual =
+                ktLintRuleEngine
+                    .interactiveFormat(Code.fromSnippet(originalCode)) { lintError ->
+                        lintError.line == 3 && lintError.detail == "Unexpected indentation (0) (should be 4)"
+                    }
+
+            assertThat(actual).isEqualTo(
+                """
+                fun main() {
+                println("Hello world!")
+                    println("Hello world!")
+                println("Hello world!")
+                }
+                """.trimIndent(),
+            )
+        }
     }
 
     @Test
@@ -358,14 +395,14 @@ class KtLintRuleEngineTest {
             ruleId = NO_VAR_RULE_ID,
             about = About(),
         ),
+        RuleAutocorrectApproveHandler,
         Rule.Experimental {
         override fun beforeVisitChildNodes(
             node: ASTNode,
-            autoCorrect: Boolean,
-            emit: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit,
+            emitAndApprove: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Boolean,
         ) {
             if (node.elementType == ElementType.VAR_KEYWORD) {
-                emit(node.startOffset, "Unexpected var, use val instead", false)
+                emitAndApprove(node.startOffset, "Unexpected var, use val instead", false)
             }
         }
 

ktlint-rule-engine/src/main/kotlin/com/pinterest/ktlint/rule/engine/api/KtLintRuleEngine.kt

@@ -18,6 +18,7 @@ import com.pinterest.ktlint.rule.engine.internal.EditorConfigFinder
 import com.pinterest.ktlint.rule.engine.internal.EditorConfigGenerator
 import com.pinterest.ktlint.rule.engine.internal.EditorConfigLoader
 import com.pinterest.ktlint.rule.engine.internal.EditorConfigLoaderEc4j
+import com.pinterest.ktlint.rule.engine.internal.LintErrorAutoCorrectHandler
 import com.pinterest.ktlint.rule.engine.internal.RuleExecutionContext.Companion.createRuleExecutionContext
 import com.pinterest.ktlint.rule.engine.internal.ThreadSafeEditorConfigCache.Companion.THREAD_SAFE_EDITOR_CONFIG_CACHE
 import org.ec4j.core.Resource
@@ -95,6 +96,9 @@ public class KtLintRuleEngine(
      * If [code] contains lint errors which have been autocorrected, then the resulting code is formatted again (up until
      * [MAX_FORMAT_RUNS_PER_FILE] times) in order to fix lint errors that might result from the previous formatting run.
      *
+     * [callback] is invoked once for each unique [LintError] found during all runs. Note that [callback] is only invoked once all format
+     * runs have been completed.
+     *
      * @throws KtLintParseException if text is not a valid Kotlin code
      * @throws KtLintRuleException in case of internal failure caused by a bug in rule implementation
      */
@@ -169,8 +173,7 @@ public class KtLintRuleEngine(
     ): String =
         codeFormatter.format(
             code = code,
-            autoCorrectHandler = AutoCorrectEnabledHandler,
-            callback = { lintError, _ -> callback(lintError) },
+            autoCorrectHandler = LintErrorAutoCorrectHandler(callback),
             maxFormatRunsPerFile = 1,
         )
 

ktlint-rule-engine/src/main/kotlin/com/pinterest/ktlint/rule/engine/internal/AutoCorrectHandler.kt

@@ -1,22 +1,41 @@
 package com.pinterest.ktlint.rule.engine.internal
 
+import com.pinterest.ktlint.rule.engine.api.LintError
+
 /**
  * Handler which determines whether autocorrect should be enabled or disabled for the given offset.
  */
 internal sealed interface AutoCorrectHandler {
     fun autoCorrect(offset: Int): Boolean
+
+    fun autoCorrect(lintError: LintError): Boolean
 }
 
 internal data object AutoCorrectDisabledHandler : AutoCorrectHandler {
     override fun autoCorrect(offset: Int) = false
+
+    override fun autoCorrect(lintError: LintError) = false
 }
 
 internal data object AutoCorrectEnabledHandler : AutoCorrectHandler {
     override fun autoCorrect(offset: Int) = true
+
+    override fun autoCorrect(lintError: LintError) = true
 }
 
+@Deprecated(message = "Replace with LintErrorAutocorrectHandler")
 internal class AutoCorrectOffsetRangeHandler(
     private val autoCorrectOffsetRange: IntRange,
 ) : AutoCorrectHandler {
     override fun autoCorrect(offset: Int) = offset in autoCorrectOffsetRange
+
+    override fun autoCorrect(lintError: LintError) = throw IllegalStateException()
+}
+
+internal class LintErrorAutoCorrectHandler(
+    private val callback: (LintError) -> Boolean,
+) : AutoCorrectHandler {
+    override fun autoCorrect(offset: Int) = true
+
+    override fun autoCorrect(lintError: LintError) = callback(lintError)
 }

ktlint-rule-engine/src/main/kotlin/com/pinterest/ktlint/rule/engine/internal/CodeFormatter.kt

@@ -112,30 +112,37 @@ internal class CodeFormatter(
     ): Set<Pair<LintError, Boolean>> {
         val errors = mutableSetOf<Pair<LintError, Boolean>>()
         executeRule(rule, autoCorrectHandler) { offset, errorMessage, canBeAutoCorrected ->
-            if (canBeAutoCorrected) {
-                // TODO: send LintError to external approve handler
+            val (line, col) = positionInTextLocator(offset)
+            val lintError = LintError(line, col, rule.ruleId, errorMessage, canBeAutoCorrected)
+            val autoCorrect =
+                if (canBeAutoCorrected) {
+                    if (autoCorrectHandler is AutoCorrectOffsetRangeHandler) {
+                        autoCorrectHandler.autoCorrect(offset)
+                    } else {
+                        autoCorrectHandler.autoCorrect(lintError)
+                    }
+                } else {
+                    false
+                }
+            if (autoCorrect) {
                 /*
                  * Rebuild the suppression locator after each change in the AST as the offsets of the suppression hints might
                  * have changed.
                  */
                 rebuildSuppressionLocator()
             }
-            val (line, col) = positionInTextLocator(offset)
-            LintError(line, col, rule.ruleId, errorMessage, canBeAutoCorrected)
-                .let { lintError ->
-                    errors.add(
-                        Pair(
-                            lintError,
-                            // It is assumed that a rule that emits that an error can be autocorrected, also does correct the error.
-                            canBeAutoCorrected,
-                        ),
-                    )
-                    // In trace mode report the violation immediately. The order in which violations are actually found might be
-                    // different from the order in which they are reported. For debugging purposes it can be helpful to know the
-                    // exact order in which violations are being solved.
-                    LOGGER.trace { "Format violation: ${lintError.logMessage(code)}" }
-                }
-            canBeAutoCorrected
+            errors.add(
+                Pair(
+                    lintError,
+                    // It is assumed that a rule that asks for autocorrect approval, also does correct the error.
+                    autoCorrect,
+                ),
+            )
+            // In trace mode report the violation immediately. The order in which violations are actually found might be
+            // different from the order in which they are reported. For debugging purposes it can be helpful to know the
+            // exact order in which violations are being solved.
+            LOGGER.trace { "Format violation: ${lintError.logMessage(code)}" }
+            autoCorrect
         }
         return errors
     }

ktlint-rule-engine/src/main/kotlin/com/pinterest/ktlint/rule/engine/internal/RuleExecutionContext.kt

@@ -91,24 +91,24 @@ internal class RuleExecutionContext private constructor(
         val suppressHandler = SuppressHandler(suppressionLocator, autoCorrectHandler, emitAndApprove)
         if (rule.shouldContinueTraversalOfAST()) {
             try {
-                executeRuleOnNodeRecursively(node, rule, autoCorrectHandler, suppressHandler)
+                executeRuleOnNodeRecursively(node, rule, autoCorrectHandler, suppressHandler, emitAndApprove)
             } catch (e: Exception) {
-                if (autoCorrectHandler.autoCorrect(node.startOffset)) {
-                    // line/col cannot be reliably mapped as exception might originate from a node not present in the
-                    // original AST
+                if (autoCorrectHandler is AutoCorrectDisabledHandler) {
+                    val (line, col) = positionInTextLocator(node.startOffset)
                     throw RuleExecutionException(
                         rule,
-                        0,
-                        0,
+                        line,
+                        col,
                         // Prevent extreme long stack trace caused by recursive call and only pass root cause
                         e.cause ?: e,
                     )
                 } else {
-                    val (line, col) = positionInTextLocator(node.startOffset)
+                    // line/col cannot be reliably mapped as exception might originate from a node not present in the
+                    // original AST
                     throw RuleExecutionException(
                         rule,
-                        line,
-                        col,
+                        0,
+                        0,
                         // Prevent extreme long stack trace caused by recursive call and only pass root cause
                         e.cause ?: e,
                     )
@@ -122,6 +122,7 @@ internal class RuleExecutionContext private constructor(
         rule: Rule,
         autoCorrectHandler: AutoCorrectHandler,
         suppressHandler: SuppressHandler,
+        emitAndApprove: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Boolean,
     ) {
         if (rule is RuleAutocorrectApproveHandler) {
             suppressHandler.handle(node, rule.ruleId) { emitAndApprove ->
@@ -139,14 +140,12 @@ internal class RuleExecutionContext private constructor(
             node
                 .getChildren(null)
                 .forEach { childNode ->
-                    suppressHandler.handle(childNode, rule.ruleId) { emitAndApprove ->
-                        this.executeRuleOnNodeRecursively(
-                            childNode,
-                            rule,
-                            autoCorrectHandler,
-                            emitAndApprove,
-                        )
-                    }
+                    this.executeRuleOnNodeRecursively(
+                        childNode,
+                        rule,
+                        autoCorrectHandler,
+                        emitAndApprove,
+                    )
                 }
         }
         if (rule is RuleAutocorrectApproveHandler) {

ktlint-rule-engine/src/main/kotlin/com/pinterest/ktlint/rule/engine/internal/SuppressHandler.kt

@@ -18,7 +18,7 @@ internal class SuppressHandler(
                 node.startOffset,
                 ruleId,
             )
-        val autoCorrect = this.autoCorrectHandler.autoCorrect(node.startOffset) && !suppress
+        val autoCorrect = this.autoCorrectHandler !is AutoCorrectDisabledHandler && !suppress
         val emit =
             if (suppress) {
                 SUPPRESS_EMIT

ktlint-rule-engine/src/main/kotlin/com/pinterest/ktlint/rule/engine/internal/SuppressionLocatorBuilder.kt

@@ -120,42 +120,41 @@ internal object SuppressionLocatorBuilder {
     private fun ASTNode.createSuppressionHintFromEolComment(formatterTags: FormatterTags): CommentSuppressionHint? =
         text
             .removePrefix("//")
-            .trim()
-            .split(" ")
-            .takeIf { it.isNotEmpty() }
-            ?.takeIf { it[0] == formatterTags.formatterTagOff }
-            ?.let { parts ->
-                CommentSuppressionHint(
-                    this,
-                    HashSet(parts.tail()),
-                    EOL,
-                )
-            }
+            .let { createCommentSuppressionHint(it, formatterTags) }
 
     private fun ASTNode.createSuppressionHintFromBlockComment(formatterTags: FormatterTags): CommentSuppressionHint? =
         text
             .removePrefix("/*")
             .removeSuffix("*/")
-            .trim()
-            .split(" ")
-            .takeIf { it.isNotEmpty() }
-            ?.let { parts ->
-                if (parts[0] == formatterTags.formatterTagOff) {
+            .let { createCommentSuppressionHint(it, formatterTags) }
+
+    private fun ASTNode.createCommentSuppressionHint(
+        comment: String,
+        formatterTags: FormatterTags,
+    ) = comment
+        .trim()
+        .split(" ")
+        .takeIf { it.isNotEmpty() }
+        ?.let { parts ->
+            when (parts[0]) {
+                formatterTags.formatterTagOff ->
                     CommentSuppressionHint(
                         this,
                         HashSet(parts.tail()),
                         BLOCK_START,
                     )
-                } else if (parts[0] == formatterTags.formatterTagOn) {
+
+                formatterTags.formatterTagOn ->
                     CommentSuppressionHint(
                         this,
                         HashSet(parts.tail()),
                         BLOCK_END,
                     )
-                } else {
+
+                else ->
                     null
-                }
             }
+        }
 
     private fun MutableList<CommentSuppressionHint>.toSuppressionHints(rootNode: ASTNode): MutableList<SuppressionHint> {
         val suppressionHints = mutableListOf<SuppressionHint>()