Treat dot-qualified scoping functions as block-like

Summary:
# AI generated
`val fn = scope.launch { doThing() }` was reformatted by ktfmt, but `val fn = launch { doThing() }` was not. Both patterns should be stable (idempotent).

`isLambdaOrScopingFunction()` only recognized `KtCallExpression` (e.g., `launch { }`), not `KtQualifiedExpression` (e.g., `scope.launch { }`). Added unwrapping for dot-qualified expressions with simple name receivers so `scope.launch { }` and `scope?.launch { }` are treated as block-like, consistent with `launch { }`.

Guarded with `receiverExpression is KtSimpleNameExpression` to avoid catching multi-part chains like `items.toMutableList.apply { }` or `if (...) { }.mapFailure { }`.

Reviewed By: cgrushko

Differential Revision: D96184015

fbshipit-source-id: 36eb699782766e523fb19cddbb8350232a3331cf

Author: Nivaldo Bondança

CHANGELOG.md

@@ -17,6 +17,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Add `--quiet` flag to suppress per-file formatting status output.
 
 ### Fixed
+- Dot-qualified scoping functions (e.g., `scope.launch { }`) now format as block-like expressions, consistent with non-qualified calls ([GH#205](https://github.com/facebook/ktfmt/issues/205))
 - Backtick-escaped full-path imports are no longer incorrectly removed as unused (https://github.com/facebook/ktfmt/issues/532)
 - Single-line comments in if expressions are now correctly indented (https://github.com/facebook/ktfmt/pull/591)
 - Idea Plugin not applying custom trailing commas management strategy (https://github.com/facebook/ktfmt/pull/593)

core/src/main/java/com/facebook/ktfmt/format/KotlinInputAstVisitor.kt

@@ -1553,6 +1553,7 @@ class KotlinInputAstVisitor(
    * 1. '... = { ... }' is a lambda expression
    * 2. '... = Runnable { ... }' is considered a scoping function
    * 3. '... = scope { ... }' '... = apply { ... }' is a scoping function
+   * 4. '... = scope.launch { ... }' is a dot-qualified scoping function
    *
    * but not:
    * 1. '... = foo() { ... }' due to the empty parenthesis
@@ -1565,6 +1566,9 @@ class KotlinInputAstVisitor(
     }
 
     var carry = expression
+    if (carry is KtQualifiedExpression && carry.receiverExpression is KtSimpleNameExpression) {
+      carry = carry.selectorExpression
+    }
     if (carry is KtCallExpression) {
       if (
           carry.valueArgumentList?.leftParenthesis == null &&
@@ -1592,6 +1596,11 @@ class KotlinInputAstVisitor(
     builder.breakOp(Doc.FillMode.INDEPENDENT, " ", expressionBreakIndent, Optional.of(breakToExpr))
 
     var carry = expr
+    if (carry is KtQualifiedExpression && carry.receiverExpression is KtSimpleNameExpression) {
+      visit(carry.receiverExpression)
+      builder.token(carry.operationSign.value)
+      carry = carry.selectorExpression
+    }
     if (carry is KtCallExpression) {
       visit(carry.calleeExpression)
       builder.space()

core/src/test/java/com/facebook/ktfmt/format/FormatterTest.kt

@@ -6807,6 +6807,84 @@ class FormatterTest {
           deduceMaxWidth = true,
       )
 
+  @Test
+  fun `dot-qualified scoping functions are block-like`() =
+      assertFormatted(
+          """
+          |/////////////////////////////////
+          |fun f() {
+          |  val fn = scope.launch {
+          |    doThing()
+          |    doAnother()
+          |  }
+          |}
+          |
+          |fun g() {
+          |  val longVariableName =
+          |      scope.launch {
+          |        doThing()
+          |        doAnother()
+          |      }
+          |}
+          |
+          |fun h() = scope.launch {
+          |  doThing()
+          |  doAnother()
+          |}
+          |
+          |fun longFunctionName() =
+          |    scope.launch {
+          |      doThing()
+          |      doAnother()
+          |    }
+          |
+          |fun j() {
+          |  x = scope.launch {
+          |    doThing()
+          |    doAnother()
+          |  }
+          |}
+          |
+          |fun k() {
+          |  longVariableName =
+          |      scope.launch {
+          |        doThing()
+          |        doAnother()
+          |      }
+          |}
+          |
+          |fun l() {
+          |  val fn = scope?.launch {
+          |    doThing()
+          |    doAnother()
+          |  }
+          |}
+          |
+          |fun m() {
+          |  val longVariableName =
+          |      scope?.launch {
+          |        doThing()
+          |        doAnother()
+          |      }
+          |}
+          |"""
+              .trimMargin(),
+          deduceMaxWidth = true,
+      )
+
+  @Test
+  fun `dot-qualified scoping functions single-line`() =
+      assertFormatted(
+          """
+          |///////////////////////////////////////////
+          |fun f() {
+          |  val fn = scope.launch { doThing() }
+          |}
+          |"""
+              .trimMargin(),
+          deduceMaxWidth = true,
+      )
+
   @Test
   fun `top level properties with other types preserve newline spacing`() {
     assertFormatted(