Merge pull request #8283 from dotty-staging/change-given-as

Drop outdated syntax for given instances

Author: odersky

community-build/community-projects/intent

@@ -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
@@ -940,14 +918,15 @@ object Parsers {
       val lookahead = in.LookaheadScanner()
       if lookahead.isIdent then
         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)
+      def skipParams(): Unit =
+        if lookahead.token == LPAREN || lookahead.token == LBRACKET then
+          lookahead.skipParens()
+          skipParams()
+        else if lookahead.isNewLine then
+          lookahead.nextToken()
+          skipParams()
+      skipParams()
+      lookahead.isIdent(nme.as)
 
     def followingIsExtension() =
       val lookahead = in.LookaheadScanner()
@@ -3502,57 +3481,44 @@ 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
+        newLineOpt()
         val vparamss =
-          if in.token == LPAREN && followingIsParamOrGivenType()
-          then paramClauses()
+          if in.token == LPAREN && in.lookaheadIn(nme.using)
+          then paramClauses(givenOnly = true)
           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()
+        newLinesOpt()
+        if isIdent(nme.as) || !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
+          if !mods.is(Inline) then
+            syntaxError("`_ <:` is only allowed for given with `inline` modifier")
+          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)
     }

community-build/community-projects/shapeless

@@ -212,7 +212,7 @@ object Scala3 with
   // end RangeOps
 
   /** Sort symbol occurrences by their start position. */
-  given OccurrenceOrdering: Ordering[SymbolOccurrence] = (x, y) =>
+  given OccurrenceOrdering as Ordering[SymbolOccurrence] = (x, y) =>
     x.range -> y.range match
     case None -> _ | _ -> None => 0
     case Some(a) -> Some(b) =>

community-build/community-projects/utest

@@ -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/parsing/Parsers.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/src/dotty/tools/dotc/semanticdb/Scala3.scala

@@ -1302,7 +1302,7 @@ class Typer extends Namer
   }
 
   def typedWhileDo(tree: untpd.WhileDo)(implicit ctx: Context): Tree = {
-    given whileCtx: Context = Nullables.whileContext(tree.span)(using ctx)
+    given whileCtx as Context = Nullables.whileContext(tree.span)(using ctx)
     val cond1 =
       if (tree.cond eq EmptyTree) EmptyTree
       else typed(tree.cond, defn.BooleanType)

compiler/src/dotty/tools/dotc/typer/Applications.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
         |}

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

@@ -88,7 +88,7 @@ But you can also do:
 assertPositioned(tree.reporting(s"Tree is: $result"))
 ```
 
-`def (a: A).reporting(f: given WrappedResult[T] => String, p: Printer = Printers.default): A` is defined on all types. The function `f` can be written without the argument since the argument is `given`. The `result` variable is a part of the `WrapperResult` – a tiny framework powering the `reporting` function. Basically, whenever you are using `reporting` on an object `A`, you can use the `result: A` variable from this function and it will be equal to the object you are calling `reporting` on.
+`def (a: A).reporting(f: WrappedResult[T] ?=> String, p: Printer = Printers.default): A` is defined on all types. The function `f` can be written without the argument since it is a context function`. The `result` variable is a part of the `WrapperResult` – a tiny framework powering the `reporting` function. Basically, whenever you are using `reporting` on an object `A`, you can use the `result: A` variable from this function and it will be equal to the object you are calling `reporting` on.
 
 ## Printing out trees after phases
 To print out the trees you are compiling after the FrontEnd (scanner, parser, namer, typer) phases:

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

@@ -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

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

@@ -50,11 +50,11 @@ val bar = foo // val bar: Int => Float = ...
 
 ## Automatic Eta-Expansion and query types
 
-A method with inferable parameters can be expanded to a value of query type by writing the expected query type explicitly.
+A method with context parameters can be expanded to a value of a context type by writing the expected context type explicitly.
 
 ```scala
-def foo(x: Int) given (p: Double): Float = ???
-val bar: given Double => Float = foo(3) // val bar: given Double => Float = ...
+def foo(x: Int)(using p: Double): Float = ???
+val bar: Double ?=> Float = foo(3)
 ```
 
 ## Rules

docs/docs/contributing/debugging.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/internals/syntax.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/changed-features/eta-expansion-spec.md

@@ -25,13 +25,13 @@ we need to implement a method `Eq.derived` on the companion object of `Eq` that
 produces a quoted instance for `Eq[T]`. Here is a possible signature,
 
 ```scala
-given derived[T: Type](using qctx: QuoteContext): Expr[Eq[T]]
+given derived[T: Type](using qctx: QuoteContext) as Expr[Eq[T]]
 ```
 
 and for comparison reasons we give the same signature we had with `inline`:
 
 ```scala
-inline given derived[T]: (m: Mirror.Of[T]) => Eq[T] = ???
+inline given derived[T] as (m: Mirror.Of[T]) => Eq[T] = ???
 ```
 
 Note, that since a type is used in a subsequent stage it will need to be lifted
@@ -41,7 +41,7 @@ from the signature. The body of the `derived` method is shown below:
 
 
 ```scala
-given derived[T: Type](using qctx: QuoteContext): Expr[Eq[T]] = {
+given derived[T: Type](using qctx: QuoteContext) as Expr[Eq[T]] = {
   import qctx.tasty.{_, given}
 
   val ev: Expr[Mirror.Of[T]] = summonExpr(using '[Mirror.Of[T]]).get
@@ -175,7 +175,7 @@ object Eq {
     case '[Unit] => Nil
   }
 
-  given derived[T: Type](using qctx: QuoteContext): Expr[Eq[T]] = {
+  given derived[T: Type](using qctx: QuoteContext) as Expr[Eq[T]] = {
     import qctx.tasty.{_, given}
 
     val ev: Expr[Mirror.Of[T]] = summonExpr(using '[Mirror.Of[T]]).get

docs/docs/reference/changed-features/implicit-resolution.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/changed-features/numeric-literals.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/contextual/derivation-macro.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] }

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

@@ -12,7 +12,7 @@ Splices can be of two forms:
 * A splice `${ ... : Bind[T] }` that can be placed on names of `val`s, `var`s or `def`s
 
 ```scala
-def foo(x: Expr[Int]) given tasty.Reflect: Expr[Int] = x match {
+def foo(x: Expr[Int])(using tasty.Reflect): Expr[Int] = x match {
   case '{ val $a: Int = $x; (${Bind(`a`)}: Int) + 1 } => '{ $x + 1 } // TODO needs fix for #6328, `a` is currently not in scope while typing
 }
 ```
@@ -21,7 +21,7 @@ In the example above we have `$a` which provides a `Bind[Int]`, `$x` which provi
 Quoted patterns are transformed during typer to a call of `scala.internal.quoted.Expr.unapply` which splits the quoted code into the patterns and a reifiable quote that will be used as witnesses at runtime.
 
 ```scala
-def foo(x: Expr[Int]) given tasty.Reflect: Expr[Int] = x match {
+def foo(x: Expr[Int])(using tasty.Reflect): Expr[Int] = x match {
   case scala.internal.quoted.Expr.unapply[Tuple3[Bind[Int], Expr[Int], Expr[Int]]](Tuple3(a, x, Bind(`a`), y))('{ @patternBindHole val a: Int = patternHole[Int]; patternHole[Int] + 1 }) =>
 }
 ```

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

@@ -11,7 +11,7 @@ object opaques:
   private[scala] type Sup[A] >: IArray[A] <: Array[_ <: A]
 
   /** Defines extension methods for immutable arrays */
-  given arrayOps: Object {
+  given arrayOps as Object {
 
     /** The selection operation on an immutable array.
       *