Implement SIP-77: End Markers for Method Blocks

Author: soronpo

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -530,6 +530,13 @@ object Trees {
      */
     def applyKind: ApplyKind =
       attachmentOrElse(untpd.KindOfApply, ApplyKind.Regular)
+
+    def setEndMarker(): this.type =
+      putAttachment(untpd.HasEndMarker, ())
+      this
+
+    def hasEndMarker: Boolean =
+      hasAttachment(untpd.HasEndMarker)
   }
 
   /** fun[args] */

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -391,6 +391,12 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   val RetainsAnnot: Property.StickyKey[Unit] = Property.StickyKey()
 
+  /** Property key for marking Apply trees with end markers */
+  val HasEndMarker: Property.StickyKey[Unit] = Property.StickyKey()
+
+  /** Property key for storing method name in Apply trees for end marker matching */
+  val MethodName: Property.StickyKey[Name] = Property.StickyKey()
+
   // ------ Creation methods for untyped only -----------------
 
   def Ident(name: Name)(implicit src: SourceFile): Ident = new Ident(name)

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -40,6 +40,7 @@ object Feature:
   val packageObjectValues = experimental("packageObjectValues")
   val multiSpreads = experimental("multiSpreads")
   val subCases = experimental("subCases")
+  val endMarkersForMethodBlocks = experimental("endMarkersForMethodBlocks")
 
   def experimentalAutoEnableFeatures(using Context): List[TermName] =
     defn.languageExperimentalFeatures
@@ -69,6 +70,7 @@ object Feature:
     (into, "Allow into modifier on parameter types"),
     (modularity, "Enable experimental modularity features"),
     (packageObjectValues, "Enable experimental package objects as values"),
+    (endMarkersForMethodBlocks, "Enable experimental end markers for method blocks"),
   )
 
   // legacy language features from Scala 2 that are no longer supported.

compiler/src/dotty/tools/dotc/config/SourceVersion.scala

@@ -47,6 +47,7 @@ enum SourceVersion:
   def enablesBetterFors(using Context) = isAtLeast(`3.8`) || (isAtLeast(`3.7`) && isPreviewEnabled)
   /** See PR #23441 and tests/neg/i23435-min */
   def enablesDistributeAnd = !isAtLeast(`3.8`)
+  def enablesEndMarkersForMethodBlocks(using Context) = isAtLeast(`3.8`) || Feature.enabled(Feature.endMarkersForMethodBlocks)
 
   def requiresNewSyntax = isAtLeast(future)
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -19,6 +19,7 @@ import NameKinds.{WildcardParamName, QualifiedName}
 import NameOps.*
 import ast.{Positioned, Trees}
 import ast.Trees.*
+import ast.untpd
 import StdNames.*
 import util.Spans.*
 import Constants.*
@@ -1543,6 +1544,7 @@ object Parsers {
       def updateSpanOfLast(last: T): Unit =
         last match
           case last: WithEndMarker[t] => last.withEndMarker()
+          case apply: Apply if sourceVersion.enablesEndMarkersForMethodBlocks => apply.setEndMarker()
           case _ =>
         last.span = last.span.withEnd(in.lastCharOffset)
 
@@ -1562,6 +1564,17 @@ object Parsers {
         case _: Match => in.token == MATCH
         case _: New => in.token == NEW
         case _: (ForYield | ForDo) => in.token == FOR
+        case apply: Apply if sourceVersion.enablesEndMarkersForMethodBlocks =>
+          // Extract method name from Apply node
+          val methodName = apply.attachmentOrElse(untpd.MethodName, null)
+          if methodName != null then
+            in.isIdent && in.name == methodName.toTermName
+          else
+            // Fallback to extracting from fun tree
+            apply.fun match
+              case Select(_, name) => in.isIdent && in.name == name.toTermName
+              case Ident(name) => in.isIdent && in.name == name.toTermName
+              case _ => false
         case _ => false
 
       def endName = if in.token == IDENTIFIER then in.name.toString else tokenString(in.token)
@@ -2922,6 +2935,23 @@ object Parsers {
     def mkApply(fn: Tree, args: (List[Tree], Boolean)): Tree =
       val res = Apply(fn, args._1)
       if args._2 then res.setApplyKind(ApplyKind.Using)
+      // Track method name for end marker support when using colon syntax
+      if sourceVersion.enablesEndMarkersForMethodBlocks then
+        val methodName = fn match
+          case Select(_, name) => name
+          case Ident(name) => name
+          case apply: Apply =>
+            // For nested Apply (e.g., test("arg"):), extract the method name from the inner Apply
+            apply.attachmentOrElse(untpd.MethodName, null) match
+              case null =>
+                apply.fun match
+                  case Select(_, name) => name
+                  case Ident(name) => name
+                  case _ => return res
+              case name => name
+          case _ => return res
+        // Store method name as attachment for end marker matching
+        res.putAttachment(untpd.MethodName, methodName)
       res
 
     val argumentExpr: () => Tree = () => expr(Location.InArgs) match

docs/_docs/reference/experimental/end-markers-method-blocks.md

@@ -0,0 +1,124 @@
+# End Markers for Method Blocks
+
+End markers for method blocks allow you to explicitly mark the end of method application blocks that use colon syntax (braceless arguments).
+
+## Syntax
+
+The syntax follows the pattern:
+
+```scala
+methodName(args):
+  // block content
+end methodName
+```
+
+## Examples
+
+### Simple Method Blocks
+
+```scala
+import scala.language.experimental.endMarkersForMethodBlocks
+
+def test(name: String)(body: => Unit): Unit =
+  println(s"Running test: $name")
+  body
+
+test("my test"):
+  val x = 1
+  assert(x > 0)
+end test
+```
+
+### Nested Calls
+
+```scala
+def foo(x: Int)(body: => Int): Int = body
+
+test("my test"):
+  foo(42):
+    val result = 42 * 2
+    result
+  end foo
+end test
+```
+
+### Apply Method Handling
+
+When dealing with `apply` methods, the end marker follows the explicit method name used in the call:
+
+**Explicit `apply` calls**: Use `end apply` when the method is called explicitly with `.apply`.
+
+```scala
+object Foo:
+  def apply(block: => Unit): Unit = ()
+
+Foo.apply:
+  // do something
+end apply
+```
+
+**Implicit `apply` calls**: Use the name of the object/class instance that owns the `apply` method when it's called implicitly.
+
+```scala
+object Foo:
+  def apply(block: => Unit): Unit = ()
+
+Foo:
+  // do something
+end Foo
+```
+
+```scala
+class Foo:
+  def apply(block: => Unit): Unit = ()
+
+val foo = new Foo
+foo:
+  // do something
+end foo
+```
+
+This rule ensures that the end marker always corresponds to the syntactically visible method name, making the code self-documenting and consistent with the principle that end markers should match the surface syntax.
+
+## How to Enable
+
+To use end markers for method blocks, you need to enable the experimental feature:
+
+```scala
+import scala.language.experimental.endMarkersForMethodBlocks
+```
+
+Alternatively, you can enable it globally with the compiler flag:
+
+```
+-language:experimental.endMarkersForMethodBlocks
+```
+
+## When to Use
+
+End markers for method blocks are particularly useful when:
+
+- You have deeply nested method calls with colon syntax
+- You want to improve code readability by explicitly marking block boundaries
+- You're working with DSLs or testing frameworks that use method blocks extensively
+
+## Limitations
+
+- End markers only work with method applications that use colon syntax (braceless arguments)
+- The end marker name must exactly match the method name
+- This feature is experimental and may undergo API changes in future releases
+
+## Error Cases
+
+The compiler will report errors for misaligned end markers:
+
+```scala
+test("my test"):
+  val x = 1
+  assert(x > 0)
+end wrong  // Error: misaligned end marker
+```
+
+## Interaction with Other Features
+
+This feature works alongside the existing `fewerBraces` feature and follows the same syntactic patterns. It extends the end marker functionality to method application blocks.

docs/_docs/reference/experimental/overview.md

@@ -11,6 +11,7 @@ All experimental language features can be found under the `scala.language.experi
 They are enabled by importing the feature or using the `-language` compiler flag.
 
 * [`erasedDefinitions`](./erased-defs.md): Enable support for `erased` modifier.
+* [`endMarkersForMethodBlocks`](./end-markers-method-blocks.md): Enable support for end markers for method blocks.
 * `fewerBraces`: Enable support for using indentation for arguments.
 * [`genericNumberLiterals`](./numeric-literals.md): Enable support for generic number literals.
 * [`namedTypeArguments`](./named-typeargs.md): Enable support for named type arguments
@@ -32,4 +33,4 @@ Hence, dependent projects also have to be experimental.
 Some experimental language features that are still in research and development can be enabled with special compiler options. These include
 
 * [`-Yexplicit-nulls`](./explicit-nulls.md). Enable support for tracking null references in the type system.
-* [`-Ycc`](./capture-checking/cc.md). Enable support for capture checking.
+* [`-Ycc`](./cc.md). Enable support for capture checking.

library/src/scala/runtime/stdLibPatches/language.scala

@@ -174,6 +174,12 @@ object language:
      */
     @compileTimeOnly("`subCases` can only be used at compile time in import statements")
     object subCases
+    /** Experimental support for end markers for method blocks.
+     *
+     *  @see [[https://github.com/scala/improvement-proposals/pull/77]]
+     */
+    @compileTimeOnly("`endMarkersForMethodBlocks` can only be used at compile time in import statements")
+    object endMarkersForMethodBlocks
   end experimental
 
   /** The deprecated object contains features that are no longer officially suypported in Scala.

tests/neg/end-markers-method-blocks.scala

@@ -0,0 +1,95 @@
+import scala.language.experimental.endMarkersForMethodBlocks
+
+object Test:
+  def test(name: String)(body: => Unit): Unit =
+    println(s"Running test: $name")
+    body
+
+  def foo(arg: Int)(block: => Unit): Unit = block
+
+  def bar(x: Int): Unit = ()
+
+  def main(args: Array[String]): Unit =
+    // Misaligned end marker example from SIP
+    def testFunction = bar:
+      //do something
+      println("inside bar")
+    end bar  // error: misaligned end marker
+
+    val baz = foo(42):
+      //do something
+    end foo // error: misaligned end marker
+    end baz
+
+    // Wrong method name examples
+    test("my test"):
+      val x = 1
+      assert(x > 0)
+    end wrong  // error
+
+    foo(42):
+      val result = 42 * 2
+      println(s"Result: $result")
+    end bar    // error
+
+    // Wrong end marker for nested blocks
+    test("nested test"):
+      val x = 1
+      val y = 2
+      val z = x + y
+      assert(z == 3)
+    end foo   // error
+
+    // Wrong end marker for complex test
+    test("complex test"):
+      val x = 1
+      val y = 2
+      val z = x + y
+      assert(z == 3)
+      println(s"Result: $z")
+    end bar   // error
+
+    // Wrong end marker for lambda
+    val elements = List(1, 2, 3)
+    elements.foreach:
+      elem =>
+        println(s"Element: $elem")
+    end test  // error
+
+    // Wrong end marker for explicit apply
+    object Foo:
+      def apply(block: => Unit): Unit = block
+
+    Foo.apply:
+      println("Explicit apply call")
+    end Foo  // error
+
+    // Wrong end marker for implicit apply
+    Foo:
+      println("Implicit apply call")
+    end apply  // error
+
+    // Wrong end marker for class instance
+    class Bar:
+      def apply(block: => Unit): Unit = block
+
+    val bar = new Bar
+    bar:
+      println("Class instance apply call")
+    end Bar  // error
+
+    // Wrong end marker for curried method
+    def curriedFoo(bar: String)(baz: String): Unit = 
+      println(s"$bar and $baz")
+
+    curriedFoo("abc"):
+      "xyz"
+    end curriedBar  // error
+
+    // Wrong end marker for extension method
+    extension (s: String)
+      def withPrefix(prefix: String): String = s"$prefix$s"
+
+    "world".withPrefix:
+      "hello"
+    end withSuffix  // error