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: