Put extensions under language.experimental.relaxedLambdaSyntax

Author: odersky

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

@@ -38,6 +38,7 @@ object Feature:
   val quotedPatternsWithPolymorphicFunctions = experimental("quotedPatternsWithPolymorphicFunctions")
   val packageObjectValues = experimental("packageObjectValues")
   val subCases = experimental("subCases")
+  val relaxedLambdaSyntax = experimental("relaxedLambdaSyntax")
 
   def experimentalAutoEnableFeatures(using Context): List[TermName] =
     defn.languageExperimentalFeatures

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

@@ -1086,18 +1086,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)
@@ -1107,7 +1109,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)
@@ -1122,7 +1126,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
@@ -1193,9 +1197,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
@@ -2432,7 +2438,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

@@ -355,6 +355,10 @@ 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.

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