Make clause interleaving experimental

Author: Sporarum

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

@@ -28,6 +28,7 @@ object Feature:
   val symbolLiterals = deprecated("symbolLiterals")
   val fewerBraces = experimental("fewerBraces")
   val saferExceptions = experimental("saferExceptions")
+  val clauseInterleaving = experimental("clauseInterleaving")
   val pureFunctions = experimental("pureFunctions")
   val captureChecking = experimental("captureChecking")
   val into = experimental("into")
@@ -76,6 +77,8 @@ object Feature:
 
   def namedTypeArgsEnabled(using Context) = enabled(namedTypeArguments)
 
+  def clauseInterleavingEnabled(using Context) = enabled(clauseInterleaving)
+
   def genericNumberLiteralsEnabled(using Context) = enabled(genericNumberLiterals)
 
   def scala2ExperimentalMacroEnabled(using Context) = enabled(scala2macros)

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

@@ -3627,8 +3627,18 @@ object Parsers {
         val mods1 = addFlag(mods, Method)
         val ident = termIdent()
         var name = ident.name.asTermName
-        val paramss = typeOrTermParamClauses(ParamOwner.Def, numLeadParams = numLeadParams)
+        val paramss = 
+          if in.featureEnabled(Feature.clauseInterleaving) then 
+            // If you are making interleaving stable manually, please refer to the PR introducing it instead, section "How to make non-experimental"
+            typeOrTermParamClauses(ParamOwner.Def, numLeadParams = numLeadParams)
+          else
+            val tparams = typeParamClauseOpt(ParamOwner.Def)
+            val vparamss = termParamClauses(numLeadParams = numLeadParams)
+
+            joinParams(tparams, vparamss)
+
         var tpt = fromWithinReturnType { typedOpt() }
+        
         if (migrateTo3) newLineOptWhenFollowedBy(LBRACE)
         val rhs =
           if in.token == EQUALS then

docs/_docs/reference/contextual/right-associative-extension-methods.md

@@ -25,7 +25,7 @@ For example:
             (using d: D)                      // <-- trailingUsing
     def +:: [U]                               // <-- rightTyParams
             (y: Y)                            // <-- rightParam
-            [V](using e: E)[W](z: Z)          // <-- rest
+            (using e: E)(z: Z)                // <-- rest
 ```
 
 
@@ -55,7 +55,7 @@ For instance, the `+::` method above would become
                       (y: Y)
                       (x: X)
                       (using d: D)
-                      [V](using e: E)[W](z: Z)
+                      (using e: E)(z: Z)
 ```
 
 This expansion has to be kept in mind when writing right-associative extension

docs/_docs/reference/other-new-features/generalized-method-syntax.md renamed to docs/_docs/reference/experimental/generalized-method-syntax.md

@@ -1,9 +1,15 @@
 ---
 layout: doc-page
 title: "Generalized Method Syntax"
-movedTo: https://docs.scala-lang.org/scala3/reference/other-new-features/generalized-method-syntax.html
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/generalized-method-syntax.html
 ---
 
+This feature is not yet part of the Scala 3 language definition. It can be made available by a language import:
+
+```scala
+import scala.language.experimental.clauseInterleaving
+```
+
 The inclusion of using clauses is not the only way in which methods have been updated, type parameter clauses are now allowed in any number and at any position.
 
 ## Syntax Changes

docs/_docs/reference/syntax.md

@@ -350,10 +350,6 @@ ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
 ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation} [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
 
-DefParamClauses   ::=  DefParamClause { DefParamClause } -- and two DefTypeParamClause cannot be adjacent
-DefParamClause    ::=  DefTypeParamClause 
-                    |  DefTermParamClause 
-                    |  UsingParamClause
 TypelessClauses   ::=  TypelessClause {TypelessClause}
 TypelessClause    ::=  DefTermParamClause
                     |  UsingParamClause
@@ -417,7 +413,7 @@ Dcl               ::=  RefineDcl
 ValDcl            ::=  ids ‘:’ Type
 VarDcl            ::=  ids ‘:’ Type
 DefDcl            ::=  DefSig ‘:’ Type
-DefSig            ::=  id [DefParamClauses] [DefImplicitClause]
+DefSig            ::=  id [DefTypeParamClause] [TypelessClauses] [DefImplicitClause]
 TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds
 
 Def               ::=  ‘val’ PatDef

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

@@ -61,6 +61,14 @@ object language:
     @compileTimeOnly("`saferExceptions` can only be used at compile time in import statements")
     object saferExceptions
 
+    /** Adds support for clause interleaving:
+      * Methods can now have as many type clauses as they like, this allows to have type bounds depend on terms: `def f(x: Int)[A <: x.type]: A`
+      *
+      * @see [[http://dotty.epfl.ch/docs/reference/other-new-features/explicit-nulls.html]]
+      */
+    @compileTimeOnly("`clauseInterleaving` can only be used at compile time in import statements")
+    object clauseInterleaving
+
     /** Experimental support for pure function type syntax
      *
      *  @see [[https://dotty.epfl.ch/docs/reference/experimental/purefuns]]

project/MiMaFilters.scala

@@ -12,12 +12,17 @@ object MiMaFilters {
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language.3.3"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$3$u002E3$"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$3$u002E3$minusmigration$"),
-    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.into"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$into$"),
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary"),
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$"),
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Break"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Label")
+    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Label"),
+
+    //  New experimental features in 3.3.X
+    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.clauseInterleaving"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$clauseInterleaving$"),
+    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.into"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$into$"),
+    // end of New experimental features in 3.3.X
   )
   val TastyCore: Seq[ProblemFilter] = Seq(
     ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.TastyBuffer.reset"),