Make given come last in instance definitions

odersky · odersky · commit c8266dca51c2 · 2019-05-09T16:55:23.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -2673,22 +2673,22 @@ object Parsers {
       Template(constr, parents, Nil, EmptyValDef, Nil)
     }
 
-    /** InstanceDef    ::=  [id] InstanceParams InstanceBody
+    /** InstanceDef    ::=  [id] [DefTypeParamClause] InstanceBody
      *  InstanceParams ::=  [DefTypeParamClause] {GivenParamClause}
-     *  InstanceBody   ::=  [‘for’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
-     *                   |  ‘for’ Type ‘=’ Expr
+     *  InstanceBody   ::=  [‘for’ ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
+     *                   |  ‘for’ Type {GivenParamClause} ‘=’ Expr
      */
     def instanceDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, instanceMod)
       val name = if (isIdent) ident() else EmptyTermName
       val tparams = typeParamClauseOpt(ParamOwner.Def)
-      val vparamss = paramClauses(ofInstance = true)
       val parents =
         if (in.token == FOR) {
           in.nextToken()
           tokenSeparated(COMMA, constrApp)
         }
         else Nil
+      val vparamss = paramClauses(ofInstance = true)
       val instDef =
         if (in.token == EQUALS && parents.length == 1 && parents.head.isType) {
           in.nextToken()
diff --git a/docs/docs/internals/syntax.md b/docs/docs/internals/syntax.md
@@ -378,10 +378,10 @@ ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses
 ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]                                            ModuleDef(mods, name, template)  // no constructor
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody                   EnumDef(mods, name, tparams, template)
-InstanceDef       ::=  [id] InstanceParams InstanceBody
+InstanceDef       ::=  [id] [DefTypeParamClause] InstanceBody
 InstanceParams    ::=  [DefTypeParamClause] {GivenParamClause}
-InstanceBody      ::=  [‘for’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
-                    |  ‘for’ Type ‘=’ Expr
+InstanceBody      ::=  [‘for’ ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
+                    |  ‘for’ Type {GivenParamClause} ‘=’ Expr
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
 ConstrApps        ::=  ConstrApp {‘with’ ConstrApp}
diff --git a/docs/docs/reference/contextual-implicit/instance-defs.md b/docs/docs/reference/contextual-implicit/instance-defs.md
@@ -71,10 +71,10 @@ An implicit instance without type parameters or given clause is created on-deman
 Here is the new syntax of implicit instances, seen as a delta from the [standard context free syntax of Scala 3](http://dotty.epfl.ch/docs/internals/syntax.html).
 ```
 TmplDef          ::=  ...
-                  |  ‘implicit’ InstanceDef
+                   |  ‘implicit’ InstanceDef
 InstanceDef      ::=  [id] [DefTypeParamClause] InstanceBody
-InstanceBody     ::=  [‘of’ ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
-                   |  ‘of’ Type {GivenParamClause} ‘=’ Expr
+InstanceBody     ::=  [‘for’ ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
+                   |  ‘for’ Type {GivenParamClause} ‘=’ Expr
 ConstrApp        ::=  AnnotType {ArgumentExprs}
                    |  ‘(’ ConstrApp {‘given’ (InfixExpr | ParArgumentExprs)} ‘)’
 GivenParamClause ::=  ‘given’ (‘(’ [DefParams] ‘)’ | GivenTypes)
diff --git a/tests/neg/i5978.scala b/tests/neg/i5978.scala
@@ -7,8 +7,8 @@ trait TokenParser[Token, R]
 object TextParser {
   implied TP for TokenParser[Char, Position[CharSequence]] {}
 
-  implied FromCharToken
-    given (T: TokenParser[Char, Position[CharSequence]]) for Conversion[Char, Position[CharSequence]] = ???
+  implied FromCharToken for Conversion[Char, Position[CharSequence]]
+    given (T: TokenParser[Char, Position[CharSequence]])  = ???
 }
 
 
diff --git a/tests/pos/i5978.scala b/tests/pos/i5978.scala
@@ -9,8 +9,8 @@ package p1 {
   object TextParser {
     implied TP for TokenParser[Char, Position[CharSequence]] {}
 
-    implied FromCharToken
-      given (T: TokenParser[Char, Position[CharSequence]]) for Conversion[Char, Position[CharSequence]] = ???
+    implied FromCharToken for Conversion[Char, Position[CharSequence]]
+      given (T: TokenParser[Char, Position[CharSequence]])= ???
   }
 
 
diff --git a/tests/pos/multiversal.scala b/tests/pos/multiversal.scala
@@ -1,7 +1,7 @@
 object Test {
   import scala.Eql
 
-  implied [X, Y] given Eql[X, Y] for Eql[List[X], List[Y]] = Eql.derived
+  implied [X, Y] for Eql[List[X], List[Y]] given Eql[X, Y] = Eql.derived
 
   val b: Byte = 1
   val c: Char = 2
diff --git a/tests/pos/reference/instances.scala b/tests/pos/reference/instances.scala
@@ -37,7 +37,7 @@ object Instances extends Common {
       if (x < y) -1 else if (x > y) +1 else 0
   }
 
-  implied ListOrd[T] given Ord[T] for Ord[List[T]] {
+  implied ListOrd[T] for Ord[List[T]] given Ord[T] {
     def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
       case (Nil, Nil) => 0
       case (Nil, _) => -1
@@ -195,7 +195,7 @@ object AnonymousInstances extends Common {
     def (xs: List[T]) second[T] = xs.tail.head
   }
 
-  implied [From, To] given (c: Convertible[From, To]) for Convertible[List[From], List[To]] {
+  implied [From, To] for Convertible[List[From], List[To]] given (c: Convertible[From, To]) {
     def (x: List[From]) convert: List[To] = x.map(c.convert)
   }
 
diff --git a/tests/run/implicit-specifity.scala b/tests/run/implicit-specifity.scala
@@ -9,7 +9,7 @@ object Show {
 class Generic
 object Generic {
   implied gen for Generic = new Generic
-  implied showGen[T] given Generic for Show[T] = new Show[T](2)
+  implied showGen[T] for Show[T] given Generic = new Show[T](2)
 }
 
 class Generic2
@@ -25,9 +25,9 @@ object SubGen {
 object Contextual {
   trait Context
   implied ctx for Context
-  implied showGen[T] given Generic for Show[T] = new Show[T](2)
-  implied showGen[T] given Generic, Context for Show[T] = new Show[T](3)
-  implied showGen[T] given SubGen for Show[T] = new Show[T](4)
+  implied showGen[T] for Show[T] given Generic = new Show[T](2)
+  implied showGen[T] for Show[T] given Generic, Context = new Show[T](3)
+  implied showGen[T] for Show[T] given SubGen = new Show[T](4)
 }
 
 object Test extends App {
diff --git a/tests/run/implied-divergence.scala b/tests/run/implied-divergence.scala
@@ -6,7 +6,7 @@ implied e for E(null)
 
 object Test extends App {
 
-  implied f given (e: E) for E(e)
+  implied f for E(e) given (e: E)
 
   assert(the[E].toString == "E(E(null))")
 
diff --git a/tests/run/implied-priority.scala b/tests/run/implied-priority.scala
@@ -15,7 +15,7 @@ class LowPriorityImplicits {
 }
 
 object NormalImplicits extends LowPriorityImplicits {
-  implied t2[T] given Arg[T] for E[T]("norm")
+  implied t2[T]for E[T]("norm") given Arg[T]
 }
 
 def test1 = {
@@ -38,8 +38,8 @@ object Priority {
 }
 
 object Impl2 {
-  implied t1[T] given Priority.Low for E[T]("low")
-  implied t2[T] given Priority.High given Arg[T] for E[T]("norm")
+  implied t1[T] for E[T]("low") given Priority.Low
+  implied t2[T] for E[T]("norm") given Priority.High given Arg[T]
 }
 
 def test2 = {
@@ -102,7 +102,7 @@ def test3 = {
  */
 object Impl4 {
   implied t1 for E[String]("string")
-  implied t2[T] given Arg[T] for E[T]("generic")
+  implied t2[T] for E[T]("generic") given Arg[T]
 }
 
 object fallback4 {
@@ -133,7 +133,7 @@ object HigherPriority {
 }
 
 object fallback5 {
-  implied [T] given (ev: E[T] = new E[T]("fallback")) for (E[T] & HigherPriority) = HigherPriority.inject(ev)
+  implied [T] for (E[T] & HigherPriority) given (ev: E[T] = new E[T]("fallback")) = HigherPriority.inject(ev)
 }
 
 def test5 = {
diff --git a/tests/run/implied-specifity-2.scala b/tests/run/implied-specifity-2.scala
@@ -15,36 +15,36 @@ class Foo[T](val i: Int)
 object Foo {
   def apply[T] given (fooT: Foo[T]): Int = fooT.i
 
-  implied foo[T]    given Low for Foo[T](0)
-  implied foobar[T] given Low for Foo[Bar[T]](1)
-  implied foobarbaz given Low for Foo[Bar[Baz]](2)
+  implied foo[T]    for Foo[T](0)        given Low
+  implied foobar[T] for Foo[Bar[T]](1)   given Low
+  implied foobarbaz for Foo[Bar[Baz]](2) given Low
 }
 class Bar[T]
 object Bar {
-  implied foobar[T] given Medium for Foo[Bar[T]](3)
-  implied foobarbaz given Medium for Foo[Bar[Baz]](4)
+  implied foobar[T] for Foo[Bar[T]](3)   given Medium
+  implied foobarbaz for Foo[Bar[Baz]](4) given Medium
 }
 class Baz
 object Baz {
-  implied baz given High for Foo[Bar[Baz]](5)
+  implied baz for Foo[Bar[Baz]](5) given High
 }
 
 class Arg
 implied for Arg
 
 class Bam(val str: String)
-implied lo given Low for Bam("lo")
-implied hi given High given Arg for Bam("hi")
+implied lo for Bam("lo") given Low
+implied hi for Bam("hi") given High given Arg
 
 class Bam2(val str: String)
-implied lo2 given Low for Bam2("lo")
-implied mid2 given High given Arg for Bam2("mid")
+implied lo2 for Bam2("lo") given Low
+implied mid2 for Bam2("mid") given High given Arg
 implied hi2 for Bam2("hi")
 
 class Arg2
 class Red(val str: String)
-implied normal given Arg2 for Red("normal")
-implied reduced given (ev: Arg2 | Low) for Red("reduced")
+implied normal for Red("normal") given Arg2
+implied reduced for Red("reduced") given (ev: Arg2 | Low)
 
 object Test extends App {
   assert(Foo[Int] == 0)
diff --git a/tests/run/tagless.scala b/tests/run/tagless.scala
@@ -196,7 +196,7 @@ object Test extends App {
   // Added operation: negation pushdown
   enum NCtx { case Pos, Neg }
 
-  implied [T] given (e: Exp[T]) for Exp[NCtx => T] {
+  implied [T] for Exp[NCtx => T] given (e: Exp[T]) {
     import NCtx._
     def lit(i: Int) = {
       case Pos => e.lit(i)
@@ -216,7 +216,7 @@ object Test extends App {
   println(pushNeg(tf1[NCtx => String]))
   println(pushNeg(pushNeg(pushNeg(tf1))): String)
 
-  implied [T] given (e: Mult[T]) for Mult[NCtx => T] {
+  implied [T] for Mult[NCtx => T] given (e: Mult[T]) {
     import NCtx._
     def mul(l: NCtx => T, r: NCtx => T): NCtx => T = {
       case Pos => e.mul(l(Pos), r(Pos))

Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,8 @@ trait TokenParser[Token, R]`
`7`	`7`	`object TextParser {`
`8`	`8`	`implied TP for TokenParser[Char, Position[CharSequence]] {}`
`9`	`9`
`10`		`- implied FromCharToken`
`11`		`- given (T: TokenParser[Char, Position[CharSequence]]) for Conversion[Char, Position[CharSequence]] = ???`
	`10`	`+ implied FromCharToken for Conversion[Char, Position[CharSequence]]`
	`11`	`+ given (T: TokenParser[Char, Position[CharSequence]]) = ???`
`12`	`12`	`}`
`13`	`13`
`14`	`14`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,8 @@ package p1 {`
`9`	`9`	`object TextParser {`
`10`	`10`	`implied TP for TokenParser[Char, Position[CharSequence]] {}`
`11`	`11`
`12`		`- implied FromCharToken`
`13`		`- given (T: TokenParser[Char, Position[CharSequence]]) for Conversion[Char, Position[CharSequence]] = ???`
	`12`	`+ implied FromCharToken for Conversion[Char, Position[CharSequence]]`
	`13`	`+ given (T: TokenParser[Char, Position[CharSequence]])= ???`
`14`	`14`	`}`
`15`	`15`
`16`	`16`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ object Instances extends Common {`
`37`	`37`	`if (x < y) -1 else if (x > y) +1 else 0`
`38`	`38`	`}`
`39`	`39`
`40`		`- implied ListOrd[T] given Ord[T] for Ord[List[T]] {`
	`40`	`+ implied ListOrd[T] for Ord[List[T]] given Ord[T] {`
`41`	`41`	`def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {`
`42`	`42`	`case (Nil, Nil) => 0`
`43`	`43`	`case (Nil, _) => -1`
`@@ -195,7 +195,7 @@ object AnonymousInstances extends Common {`
`195`	`195`	`def (xs: List[T]) second[T] = xs.tail.head`
`196`	`196`	`}`
`197`	`197`
`198`		`- implied [From, To] given (c: Convertible[From, To]) for Convertible[List[From], List[To]] {`
	`198`	`+ implied [From, To] for Convertible[List[From], List[To]] given (c: Convertible[From, To]) {`
`199`	`199`	`def (x: List[From]) convert: List[To] = x.map(c.convert)`
`200`	`200`	`}`
`201`	`201`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ class LowPriorityImplicits {`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`object NormalImplicits extends LowPriorityImplicits {`
`18`		`- implied t2[T] given Arg[T] for E[T]("norm")`
	`18`	`+ implied t2[T]for E[T]("norm") given Arg[T]`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`def test1 = {`
`@@ -38,8 +38,8 @@ object Priority {`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`object Impl2 {`
`41`		`- implied t1[T] given Priority.Low for E[T]("low")`
`42`		`- implied t2[T] given Priority.High given Arg[T] for E[T]("norm")`
	`41`	`+ implied t1[T] for E[T]("low") given Priority.Low`
	`42`	`+ implied t2[T] for E[T]("norm") given Priority.High given Arg[T]`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`def test2 = {`
`@@ -102,7 +102,7 @@ def test3 = {`
`102`	`102`	`*/`
`103`	`103`	`object Impl4 {`
`104`	`104`	`implied t1 for E[String]("string")`
`105`		`- implied t2[T] given Arg[T] for E[T]("generic")`
	`105`	`+ implied t2[T] for E[T]("generic") given Arg[T]`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`object fallback4 {`
`@@ -133,7 +133,7 @@ object HigherPriority {`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`object fallback5 {`
`136`		`- implied [T] given (ev: E[T] = new E[T]("fallback")) for (E[T] & HigherPriority) = HigherPriority.inject(ev)`
	`136`	`+ implied [T] for (E[T] & HigherPriority) given (ev: E[T] = new E[T]("fallback")) = HigherPriority.inject(ev)`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`def test5 = {`