Put extensions under language.experimental.relaxedLambdaSyntax

Author: odersky

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 relaxedLambdaSyntax = experimental("relaxedLambdaSyntax")
 
   def experimentalAutoEnableFeatures(using Context): List[TermName] =
     defn.languageExperimentalFeatures

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

@@ -1091,18 +1091,20 @@ object Parsers {
 
     /** Is the token sequence following the current `:` token classified as a lambda?
      *  If yes return a defined parsing function to parse the lambda body, if not
-     *  return None. The case is triggered in two :if the input starts with an identifier,
-     *  a wildcard, or something enclosed in (...) or [...], this is followed by a
-     *  `=>` or `?=>`, one one of the following two cases applies:
-     *    1. The next token is an indent. In this case the return parsing function parses
-     *       an Expr in location Location.InColonArg.
-     *    2. The next token is on the same line and the enclosing region is not `(...)`.
-     *       In this case the parsing function parses an Expr in location Location.InColonArg
-     *       enclosed in a SingleLineLambda region, and then eats the ENDlambda token
-     *       generated by the Scanner at the end of that region.
-     *  The reason for excluding (2) in regions enclosed in parentheses is to avoid
-     *  an ambiguity with type ascription `(x: A => B)`, where function types are only
-     *  allowed inside parentheses.
+     *  return None. The case is triggered in two situations:
+     *   1. If the input starts with an identifier, a wildcard, or something
+     *      enclosed in (...) or [...], this is followed by a `=>` or `?=>`,
+     *      and one of the following two subcases applies:
+     *     1a. The next token is an indent. In this case the return parsing function parses
+     *         an Expr in location Location.InColonArg.
+     *     1b. Under relaxedLambdaSyntax: the next token is on the same line and the enclosing region is not `(...)`.
+     *         In this case the parsing function parses an Expr in location Location.InColonArg
+     *         enclosed in a SingleLineLambda region, and then eats the ENDlambda token
+     *         generated by the Scanner at the end of that region.
+     *     The reason for excluding (1b) in regions enclosed in parentheses is to avoid
+     *     an ambiguity with type ascription `(x: A => B)`, where function types are only
+     *     allowed inside parentheses.
+     *   2. Under relaxedLambdaSyntax: the input starts with a `case`.
      */
     def followingIsLambdaAfterColon(): Option[() => Tree] =
       val lookahead = in.LookaheadScanner(allowIndent = true)
@@ -1112,7 +1114,9 @@ object Parsers {
           lookahead.observeArrowIndented()
           if lookahead.token == INDENT || lookahead.token == EOF then
             Some(() => expr(Location.InColonArg))
-          else if !in.currentRegion.isInstanceOf[InParens] then
+          else if in.featureEnabled(Feature.relaxedLambdaSyntax)
+              && !in.currentRegion.isInstanceOf[InParens]
+          then
             Some: () =>
               val t = inSepRegion(SingleLineLambda(_)):
                 expr(Location.InColonArg)
@@ -1127,7 +1131,7 @@ object Parsers {
       else if lookahead.token == LPAREN || lookahead.token == LBRACKET then
         lookahead.skipParens()
         isArrowIndent()
-      else if lookahead.token == CASE then
+      else if lookahead.token == CASE && in.featureEnabled(Feature.relaxedLambdaSyntax) then
         Some(() => singleCaseMatch())
       else
         None
@@ -1198,9 +1202,11 @@ object Parsers {
     /** Optionally, if we are seeing a lambda argument after a colon of the form
      *    : (params) =>
      *      body
-     *  or a single-line lambda
+     *  or a single-line lambda (under relaxedLambdaSyntax)
      *    : (params) => body
-     *  then return the function used to parse `body`.
+     *  or a case clause (under relaxedLambdaSyntax)
+     *    : case pat guard => rhs
+     *  then return the function used to parse `body` or the case clause.
      */
     def detectColonLambda: Option[() => Tree] =
       if sourceVersion.enablesFewerBraces && in.token == COLONfollow
@@ -2437,7 +2443,7 @@ object Parsers {
           val arrowOffset = accept(ARROW)
           val body = expr(location)
           makePolyFunction(tparams, body, "literal", errorTermTree(arrowOffset), start, arrowOffset)
-        case CASE =>
+        case CASE if in.featureEnabled(Feature.relaxedLambdaSyntax) =>
           singleCaseMatch()
         case _ =>
           val saved = placeholderParams

library/src/scala/language.scala

@@ -367,6 +367,11 @@ object language {
      */
     @compileTimeOnly("`subCases` can only be used at compile time in import statements")
     object subCases
+
+   /** Experimental support for single-line lambdas and case clause expressions after `:`
+     */
+    @compileTimeOnly("`relaxedLambdaSyntax` can only be used at compile time in import statements")
+    object relaxedLambdaSyntax
   }
 
     /** The deprecated object contains features that are no longer officially suypported in Scala.

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

@@ -174,6 +174,11 @@ object language:
      */
     @compileTimeOnly("`subCases` can only be used at compile time in import statements")
     object subCases
+
+    /** Experimental support for single-line lambdas and case clause expressions after `:`
+     */
+    @compileTimeOnly("`relaxedLambdaSyntax` can only be used at compile time in import statements")
+    object relaxedLambdaSyntax
   end experimental
 
   /** The deprecated object contains features that are no longer officially suypported in Scala.

tests/neg/closure-args.scala

@@ -1,4 +1,4 @@
-
+import language.experimental.relaxedLambdaSyntax
 val x = List(1).map: (x: => Int) => // error
   ???
 val z = List(1).map: + => // ok

tests/neg/i22193.scala

@@ -1,4 +1,4 @@
-
+import language.experimental.relaxedLambdaSyntax
 def fn2(arg: String, arg2: String)(f: String => Unit): Unit = f(arg)
 
 def fn3(arg: String, arg2: String)(f: => Unit): Unit = f

tests/neg/i22906.scala

@@ -1,6 +1,6 @@
 //> using options -rewrite -indent
 //> nominally using scala 3.7.0-RC1
 // does not reproduce under "vulpix" test rig, which enforces certain flag sets?
-
+import language.experimental.relaxedLambdaSyntax
 def program: Int => Int =
     {`1`: Int  =>  5} // error // error

tests/pos/change-lambda.scala

@@ -1,3 +1,5 @@
+import language.experimental.relaxedLambdaSyntax
+
 def foo(x: Any) = ???
 
 def test(xs: List[Int]) =

tests/pos/closure-args.scala

@@ -1,3 +1,4 @@
+import language.experimental.relaxedLambdaSyntax
 
 val z = List(1).map: + => // ok
   ???

tests/run/single-case-expr.scala

@@ -1,3 +1,5 @@
+import language.experimental.relaxedLambdaSyntax
+
 case class Foo(x: Int, y: Int)
 @main def Test =
   val f: List[Int] => Int = case y :: ys => y
@@ -25,6 +27,13 @@ case class Foo(x: Int, y: Int)
   val a3 = Seq((1, 2), (3, 4)).collect: case (a, b) if b > 2 => a
   assert(a3 == Seq(3))
 
+  val a4 = Seq((1, 2), (3, 4)).collect: case (a, b) if b > 2 =>
+    a
+
   val partial: PartialFunction[(Int, Int), Int] = case (a, b) if b > 2 => a
 
+  val mtup = (1, true).map: [T] => (x: T) => List(x)
+  val _: (List[Int], List[Boolean]) = mtup
+
+