Drop given-: syntax

Author: odersky

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

@@ -910,28 +910,6 @@ object Parsers {
         followedByToken(LARROW) // `<-` comes before possible statement starts
     }
 
-    /** Are the next tokens a prefix of a formal parameter or given type?
-     *  @pre: current token is LPAREN
-     *  TODO: Drop once syntax has stabilized
-     */
-    def followingIsParamOrGivenType() =
-      val lookahead = in.LookaheadScanner()
-      lookahead.nextToken()
-      if startParamTokens.contains(lookahead.token)
-         || lookahead.isIdent(nme.using)
-      then true
-      else if lookahead.token == IDENTIFIER then
-        if lookahead.name == nme.inline then
-          lookahead.nextToken()
-        if lookahead.token == IDENTIFIER then
-          lookahead.nextToken()
-          if lookahead.token == COLON then
-            lookahead.nextToken()
-            !lookahead.isAfterLineEnd
-          else false
-        else false
-      else false
-
     /** Are the next token the "GivenSig" part of a given definition,
      *  i.e. an identifier followed by type and value parameters, followed by `:`?
      *  @pre  The current token is an identifier
@@ -942,12 +920,7 @@ object Parsers {
         lookahead.nextToken()
       while lookahead.token == LPAREN || lookahead.token == LBRACKET do
         lookahead.skipParens()
-      if lookahead.token == COLON then // TODO: remove
-        lookahead.nextToken()
-        !lookahead.isAfterLineEnd
-      else
-        lookahead.token == SUBTYPE  // TODO: remove
-        || lookahead.isIdent(nme.as)
+      lookahead.isIdent(nme.as)
 
     def followingIsExtension() =
       val lookahead = in.LookaheadScanner()
@@ -3502,57 +3475,37 @@ object Parsers {
      *                      |  [GivenSig] ConstrApps [TemplateBody]
      *  GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClauses} ‘as’
      */
-    def givenDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
-      var mods1 = addMod(mods, instanceMod)
+    def givenDef(start: Offset, mods: Modifiers, givenMod: Mod) = atSpan(start, nameStart) {
+      var mods1 = addMod(mods, givenMod)
       val hasGivenSig = followingIsGivenSig()
       val nameStart = in.offset
       val name = if isIdent && hasGivenSig then ident() else EmptyTermName
 
       val gdef = in.endMarkerScope(if name.isEmpty then GIVEN else name) {
-        val hasLabel = !name.isEmpty && in.token == COLON || isIdent(nme.as)
-        if hasLabel then in.nextToken()
         val tparams = typeParamClauseOpt(ParamOwner.Def)
-        val paramsStart = in.offset
-        val vparamss =
-          if in.token == LPAREN && followingIsParamOrGivenType()
-          then paramClauses()
-          else Nil
-        def checkAllGivens(vparamss: List[List[ValDef]], what: String) =
-          vparamss.foreach(_.foreach(vparam =>
-            if !vparam.mods.is(Given) then syntaxError(em"$what must be preceded by `using`", vparam.span)))
-        checkAllGivens(vparamss, "parameter of given instance")
-        val parents =
-          if in.token == SUBTYPE && !hasLabel then
-            if !mods.is(Inline) then
-              syntaxError("`<:` is only allowed for given with `inline` modifier")
-            in.nextToken()
-            TypeBoundsTree(EmptyTree, toplevelTyp()) :: Nil
-          else
-            if !hasLabel && !(name.isEmpty && tparams.isEmpty && vparamss.isEmpty) then
-              if in.token == COLON then in.nextToken()
-              else accept(nme.as)
-            if in.token == USCORE then
-              in.nextToken()
-              accept(SUBTYPE)
-              TypeBoundsTree(EmptyTree, toplevelTyp()) :: Nil
-            else
-              constrApps(commaOK = true, templateCanFollow = true)
-
-        if in.token == EQUALS && parents.length == 1 && parents.head.isType then
-          in.nextToken()
+        val vparamss = paramClauses(givenOnly = true)
+        if !name.isEmpty || !tparams.isEmpty || !vparamss.isEmpty then
+          accept(nme.as)
+        def givenAlias(tpt: Tree) =
+          accept(EQUALS)
           mods1 |= Final
-          DefDef(name, tparams, vparamss, parents.head, subExpr())
+          DefDef(name, tparams, vparamss, tpt, subExpr())
+        if in.token == USCORE then
+          in.nextToken()
+          accept(SUBTYPE)
+          givenAlias(TypeBoundsTree(EmptyTree, toplevelTyp()))
         else
-          parents match
-            case (_: TypeBoundsTree) :: _ => syntaxError("`=` expected")
-            case _ =>
-          possibleTemplateStart()
-          val tparams1 = tparams.map(tparam => tparam.withMods(tparam.mods | PrivateLocal))
-          val vparamss1 = vparamss.map(_.map(vparam =>
-            vparam.withMods(vparam.mods &~ Param | ParamAccessor | PrivateLocal)))
-          val templ = templateBodyOpt(makeConstructor(tparams1, vparamss1), parents, Nil)
-          if tparams.isEmpty && vparamss.isEmpty then ModuleDef(name, templ)
-          else TypeDef(name.toTypeName, templ)
+          val parents = constrApps(commaOK = true, templateCanFollow = true)
+          if in.token == EQUALS && parents.length == 1 && parents.head.isType then
+            givenAlias(parents.head)
+          else
+            possibleTemplateStart()
+            val tparams1 = tparams.map(tparam => tparam.withMods(tparam.mods | PrivateLocal))
+            val vparamss1 = vparamss.map(_.map(vparam =>
+              vparam.withMods(vparam.mods &~ Param | ParamAccessor | PrivateLocal)))
+            val templ = templateBodyOpt(makeConstructor(tparams1, vparamss1), parents, Nil)
+            if tparams.isEmpty && vparamss.isEmpty then ModuleDef(name, templ)
+            else TypeDef(name.toTypeName, templ)
       }
       finalizeDef(gdef, mods1, start)
     }

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1412,7 +1412,7 @@ trait Applications extends Compatibility {
     /** Widen the result type of synthetic given methods from the implementation class to the
      *  type that's implemented. Example
      *
-     *      given I[X] : T { ... }
+     *      given I[X] as T { ... }
      *
      *  This desugars to
      *
@@ -1422,7 +1422,7 @@ trait Applications extends Compatibility {
      *  To compare specificity we should compare with `T`, not with its implementation `I[X]`.
      *  No such widening is performed for given aliases, which are not synthetic. E.g.
      *
-     *      given J[X] : T = rhs
+     *      given J[X] as T = rhs
      *
      *  already has the right result type `T`. Neither is widening performed for given
      *  objects, since these are anyway taken to be more specific than methods

compiler/src/dotty/tools/dotc/typer/Deriving.scala

@@ -122,11 +122,11 @@ trait Deriving {
         //
         //     ADT: C[A, B]               (A, B have same kinds at T, U)
         //
-        //          given derived$TC      : TC[              C         ]  // a "natural" instance
+        //          given derived$TC      as TC[              C         ]  // a "natural" instance
         //
         //     ADT: C[A]                  (A has same kind as U)
         //
-        //          given derived$TC      : TC[[t, u] =>>    C[      u]]
+        //          given derived$TC      as TC[[t, u] =>>    C[      u]]
         //
         // (b) The type class and all ADT type parameters are of kind *
         //

compiler/test/dotty/tools/repl/ReplCompilerTests.scala

@@ -151,7 +151,7 @@ class ReplCompilerTests extends ReplTest {
         |  def (x: T) > (y: T) = compare(x, y) > 0
         |}
         |
-        |given IntOrd : Ord[Int] {
+        |given IntOrd as Ord[Int] {
         |  def compare(x: Int, y: Int) =
         |  if (x < y) -1 else if (x > y) +1 else 0
         |}

docs/docs/internals/syntax.md

@@ -296,7 +296,7 @@ HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (id [HkTypeParamClause]
                        SubtypeBounds
 
 ClsParamClauses   ::=  {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
-ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’ 
+ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
                     |  [nl] ‘(’ ‘using’ (ClsParams | Types) ‘)’
 ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation}                                             ValDef(mods, id, tpe, expr) -- point of mods on val/var

docs/docs/reference/changed-features/implicit-resolution.md

@@ -43,10 +43,10 @@ affect implicits on the language level.
     Example:
     ```scala
     package p
-    given a : A
+    given a as A
 
     object o {
-      given b : B
+      given b as B
       type C
     }
     ```

docs/docs/reference/changed-features/numeric-literals.md

@@ -156,7 +156,7 @@ object BigFloat {
 To accept `BigFloat` literals, all that's needed in addition is a given instance of type
 `FromDigits.Floating[BigFloat]`:
 ```scala
-  given FromDigits : FromDigits.Floating[BigFloat] {
+  given FromDigits as FromDigits.Floating[BigFloat] {
     def fromDigits(digits: String) = apply(digits)
   }
 } // end BigFloat

docs/docs/reference/metaprogramming/erased-terms-spec.md

@@ -32,7 +32,7 @@ title: "Erased Terms Spec"
 
 3. Functions
    * `(erased x1: T1, x2: T2, ..., xN: TN) => y : (erased T1, T2, ..., TN) => R`
-   * `(given erased x1: T1, x2: T2, ..., xN: TN) => y : (given erased T1, T2, ..., TN) => R`
+   * `(given erased x1: T1, x2: T2, ..., xN: TN) => y as (given erased T1, T2, ..., TN) => R`
    * `(given erased T1) => R  <:<  erased T1 => R`
    * `(given erased T1, T2) => R  <:< (erased T1, T2) => R`
    *  ...

docs/docs/reference/metaprogramming/macros-spec.md

@@ -191,7 +191,7 @@ With the right extractors, the "AsFunction" conversion
 that maps expressions over functions to functions over expressions can
 be implemented in user code:
 ```scala
-given AsFunction1[T, U] : Conversion[Expr[T => U], Expr[T] => Expr[U]] {
+given AsFunction1[T, U] as Conversion[Expr[T => U], Expr[T] => Expr[U]] {
   def apply(f: Expr[T => U]): Expr[T] => Expr[U] =
    (x: Expr[T]) => f match {
      case Lambda(g) => g(x)

docs/docs/reference/metaprogramming/macros.md

@@ -289,7 +289,7 @@ given Liftable[Int] {
 Since `Liftable` is a type class, its instances can be conditional. For example,
 a `List` is liftable if its element type is:
 ```scala
-given [T: Liftable : Type] : Liftable[List[T]] {
+given [T: Liftable : Type] as Liftable[List[T]] {
   def toExpr(xs: List[T]) = xs match {
     case head :: tail => '{ ${ Expr(head) } :: ${ toExpr(tail) } }
     case Nil => '{ Nil: List[T] }