Allow normal parameter clauses after context parameters.

There are valid use cases, and syntactic awkwardness can be kept in check
by the "one space following a with clause" rule.

Author: odersky

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

@@ -2917,17 +2917,23 @@ object Parsers {
     }
 
     /** ClsParamClauses   ::=  {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
-     *                      |  {ClsParamClause} {GivenClsParamClause}
+     *                      |  ClsParamClause ClsParamClauses
+     *                      |  ClsParamClauses1
+     *  ClsParamClauses1  ::=  WithClsParamClause ClsParamClauses
+     *                      |  AnnotTypes ClsParamClauses1ClsParamClauses
      *  DefParamClauses   ::=  {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]
-     *                      |  {DefParamClause} {GivenParamClause}
+     *                      |  DefParamClause DefParamClauses
+     *                      |  DefParamClauses1
+     *  DefParamClauses1  ::=  WithCaramClause DefParamClauses
+     *                      |  AnnotTypes DeParamClauses1
      *
      *  @return  The parameter definitions
      */
     def paramClauses(ofClass: Boolean = false,
                      ofCaseClass: Boolean = false,
                      givenOnly: Boolean = false): List[List[ValDef]] =
 
-      def recur(firstClause: Boolean, nparams: Int, givenOnly: Boolean): List[List[ValDef]] =
+      def recur(firstClause: Boolean, nparams: Int): List[List[ValDef]] =
         newLineOptWhenFollowedBy(LPAREN)
         val prefixMods =
           if in.token == WITH && in.ch != Chars.LF then // TODO: remove LF test
@@ -2949,14 +2955,17 @@ object Parsers {
             || params.nonEmpty && params.head.mods.flags.is(Given)
           params :: (
             if lastClause then Nil
-            else recur(firstClause = false, nparams + params.length, givenOnly | isGivenClause))
+            else recur(firstClause = false, nparams + params.length))
         else if prefixMods.is(Given) then
           val params = givenTypes(annotType, nparams, ofClass)
-          params :: recur(firstClause = false, nparams + params.length, true)
+          params :: (
+            if in.token == WITH then recur(firstClause = false, nparams + params.length)
+            else Nil
+          )
         else Nil
       end recur
 
-      recur(firstClause = true, 0, givenOnly)
+      recur(firstClause = true, 0)
     end paramClauses
 
 /* -------- DEFS ------------------------------------------- */
@@ -3448,11 +3457,12 @@ object Parsers {
         syntaxError(i"extension clause can only define methods", stat.span)
     }
 
-    /** GivenDef       ::=  [GivenSig] [‘_’ ‘<:’] Type ‘=’ Expr
-     *                   |  [GivenSig] ConstrApps [TemplateBody]
-     *  GivenSig       ::=  [id] [DefTypeParamClause] GivenParamClauses ‘as’
-     *  ExtParamClause ::=  [DefTypeParamClause] DefParamClause
-     *  ExtMethods     ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
+    /** GivenDef          ::=  [GivenSig] [‘_’ ‘<:’] Type ‘=’ Expr
+     *                      |  [GivenSig] ConstrApps [TemplateBody]
+     *  GivenSig          ::=  [id] [DefTypeParamClause] {WithParamsOrTypes} ‘as’
+     *  ExtParamClause    ::=  [DefTypeParamClause] DefParamClause
+     *  ExtMethods        ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
+     *  WithParamsOrTypes ::=  WithParamClause | AnnotTypes
      */
     def givenDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, instanceMod)

docs/docs/internals/syntax.md

@@ -299,19 +299,26 @@ HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (Id[HkTypeParamClause] |
                        SubtypeBounds
 
 ClsParamClauses   ::=  {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
-                    |  {ClsParamClause} {WithClsParamClause}
+                    |  ClsParamClause ClsParamClauses
+                    |  ClsParamClauses1
+ClsParamClauses1  ::=  WithClsParamClause ClsParamClauses
+                    |  AnnotTypes ClsParamClauses1
 ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
-WithClsParamClause::= ‘with’ (‘(’ (ClsParams | Types) ‘)’ | AnnotTypes)
+WithClsParamClause::= ‘with’ ‘(’ (ClsParams | Types) ‘)’
 ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation}                                             ValDef(mods, id, tpe, expr) -- point of mods on val/var
                        [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
 Param             ::=  id ‘:’ ParamType [‘=’ Expr]
                     |  INT
 
 DefParamClauses   ::=  {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]
-                    |  {DefParamClause} {WithParamClause}
+                    |  DefParamClause DefParamClauses
+                    |  DefParamClauses1
+DefParamClauses1  ::=  WithParamClause DefParamClauses
+                    |  AnnotTypes DefParamClauses1
 DefParamClause    ::=  [nl] ‘(’ DefParams ‘)’
-WithParamClause   ::=  ‘with’ (‘(’ (DefParams | Types) ‘)’ | AnnotTypes)
+WithParamClause   ::=  ‘with’ (‘(’ (DefParams | Types) ‘)’
+WithParamsOrTypes ::=  WithParamClause | AnnotTypes
 DefParams         ::=  DefParam {‘,’ DefParam}
 DefParam          ::=  {Annotation} [‘inline’] Param                            ValDef(mods, id, tpe, expr) -- point of mods at id.
 ClosureMods       ::=  { ‘implicit’ | ‘given’}
@@ -390,8 +397,8 @@ ObjectDef         ::=  id [Template]
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody                   EnumDef(mods, name, tparams, template)
 GivenDef          ::=  [GivenSig] [‘_’ ‘<:’] Type ‘=’ Expr
                     |  [GivenSig] ConstrApps [TemplateBody]
-GivenSig          ::=  [id] [DefTypeParamClause] {WithParamClause} ‘as’
-ExtensionDef      ::=  [id] ‘on’ ExtParamClause {WithParamClause} ExtMethods
+GivenSig          ::=  [id] [DefTypeParamClause] {WithParamsOrTypes} ‘as’
+ExtensionDef      ::=  [id] ‘on’ ExtParamClause {WithParamsOrTypes} ExtMethods
 ExtMethods        ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)

docs/docs/reference/contextual/context-parameters.md

@@ -69,7 +69,7 @@ maximum(xs).with(descending.with(listOrd.with(intOrd)))
 
 ## Multiple With Clauses
 
-There can be several with clauses in a definition and with clauses can be freely interspersed with normal parameters. Example:
+There can be several with clauses in a definition. Example:
 ```scala
 def f(u: Universe) with (ctx: u.Context) with (s: ctx.Symbol, k: ctx.Kind) = ...
 ```
@@ -88,6 +88,17 @@ f(global).with(ctx).with(sym, kind)
 ```
 But `f(global).with(sym, kind)` would give a type error.
 
+With clauses can be freely interspersed with normal parameters, but a normal parameter clause cannot
+directly follow a with parameter clause consisting only of types outside parentheses. So the following is illegal:
+```scala
+def f with A, B (x: C) = ...
+```
+But the following variants are valid:
+```scala
+def g with A, B with (x: C) = ...
+def h with (A, B) (x: C) = ...
+```
+
 ## Summoning Instances
 
 The method `summon` in `Predef` returns the given of a specific type. For example,
@@ -105,9 +116,15 @@ def summon[T] with (x: T): x.type = x
 Here is the new syntax of parameters and arguments seen as a delta from the [standard context free syntax of Scala 3](../../internals/syntax.md).
 ```
 ClsParamClauses     ::=  ...
-                      |  {ClsParamClause} {WithClsParamClause}
+                      |  ClsParamClause ClsParamClauses
+                      |  ClsParamClauses1
+ClsParamClauses1    ::=  WithClsParamClause ClsParamClauses
+                      |  AnnotTypes ClsParamClauses1
 DefParamClauses     ::=  ...
-                      |  {DefParamClause} {WithParamClause}
+                      |  DefParamClause DefParamClauses
+                      |  DefParamClauses1
+DefParamClauses1    ::=  WithParamClause DefParamClauses
+                      |  AnnotTypes DefParamClauses1
 WithClsParamClause  ::=  ‘with’ (‘(’ (ClsParams | Types) ‘)’ | AnnotTypes)
 WithParamClause     ::=  ‘with’ (‘(’ (DefParams | Types) ‘)’ | AnnotTypes)
 Types               ::=  Type {‘,’ Type}

docs/docs/reference/contextual/givens.md

@@ -42,7 +42,7 @@ parameters, which are explained in the [next section](./context-parameters.md).
 The name of a given can be left out. So the definitions
 of the last section can also be expressed like this:
 ```scala
-given as Ord[Int] { ... }
+given Ord[Int] { ... }
 given [T] with Ord[T] as Ord[List[T]] { ... }
 ```
 If the name of a given is missing, the compiler will synthesize a name from
@@ -90,9 +90,10 @@ is created for each reference.
 Here is the new syntax for givens, seen as a delta from the [standard context free syntax of Scala 3](../../internals/syntax.md).
 
 ```
-TmplDef          ::=  ...
-                  |   ‘given’ GivenDef
-GivenDef         ::=  GivenSig [‘_’ ‘<:’] Type ‘=’ Expr
-                  |   GivenSig ConstrApp {‘,’ ConstrApp } [TemplateBody]
-GivenSig         ::=  [id] [DefTypeParamClause] {WithParamClause} ‘of’
+TmplDef           ::=  ...
+                   |   ‘given’ GivenDef
+GivenDef          ::=  [GivenSig] [‘_’ ‘<:’] Type ‘=’ Expr
+                   |   [GivenSig] ConstrApp {‘,’ ConstrApp } [TemplateBody]
+GivenSig          ::=  [id] [DefTypeParamClause] {WithParamsOrTypes} ‘as’
+WithParamsOrTypes ::=  WithParamClause | AnnotTypes
 ```

tests/neg/given-eta.scala

@@ -3,7 +3,9 @@ trait D
    type T
    def trans(other: T): T
 
-def h(d: D) with (x: d.T) (y: d.T) = (d.trans(x), d.trans(y)) // error: normal parameter cannot follow context parameter
+def h(d: D) with (x: d.T) (y: d.T) = (d.trans(x), d.trans(y))
 
 val z = h   // error: no implicit argument of type d.T was found for parameter x of method h
 
+def f with (D) (x: Int) = x  // OK
+def g with D (x: Int) = x  // error // error

tests/neg/implicit-params.scala

@@ -5,7 +5,7 @@ object Test {
 
   def f(x: Int) with (c: C) = x + c.x
 
-  def g0(x: Int) with (c: C) (y: Int) = x + c.x + y // error: normal parameter cannot follow context parameter
+  def g0(x: Int) with (c: C) (y: Int) = x + c.x + y
 
   def g(x: Int) with (c: C) with D = x + c.x + summon[D].x  // OK
 

tests/pos/reference/delegates.scala

@@ -22,6 +22,7 @@ class Common:
     def [A, B](x: F[A]) map (f: A => B) = x.flatMap(f `andThen` pure)
 
     def pure[A](x: A): F[A]
+end Common
 
 object Instances extends Common:
 

tests/run/given-eta.scala

@@ -0,0 +1,19 @@
+class C(val x: Int)
+
+trait D
+   type T
+   def trans(other: T): T
+
+def f(x: Int) with (c: C) (y: Int) = x + c.x + y
+def g(x: Int) with (d: D) (y: d.T): d.T = d.trans(y)
+
+@main def Test =
+  given C(1)
+  val x = f
+  assert(x(2)(3) == 6)
+
+  given D
+    type T = Int
+    def trans(other: T) = 2 * other
+  val y = g
+  assert(y(2)(3) == 6)