Implement syntax change from delegate to given

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -825,7 +825,7 @@ object desugar {
    */
   def normalizeName(mdef: MemberDef, impl: Tree)(implicit ctx: Context): Name = {
     var name = mdef.name
-    if (name.isEmpty) name = name.likeSpaced(s"${inventName(impl)}_instance".toTermName)
+    if (name.isEmpty) name = name.likeSpaced(s"${inventName(impl)}_given".toTermName)
     if (ctx.owner == defn.ScalaPackageClass && defn.reservedScalaClassNames.contains(name.toTypeName)) {
       def kind = if (name.isTypeName) "class" else "object"
       ctx.error(em"illegal redefinition of standard $kind $name", mdef.sourcePos)

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -386,6 +386,7 @@ object StdNames {
     val array_length : N        = "array_length"
     val array_update : N        = "array_update"
     val arraycopy: N            = "arraycopy"
+    val as: N                   = "as"
     val asTerm: N               = "asTerm"
     val asModule: N             = "asModule"
     val asMethod: N             = "asMethod"

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

@@ -194,12 +194,16 @@ object Parsers {
     /** Is current token a hard or soft modifier (in modifier position or not)? */
     def isModifier: Boolean = modifierTokens.contains(in.token) || in.isSoftModifier
 
-    def isBindingIntro: Boolean =
-      canStartBindingTokens.contains(in.token) &&
-      !in.isSoftModifierInModifierPosition
+    def isBindingIntro: Boolean = {
+      in.token match {
+        case USCORE | LPAREN => true
+        case IDENTIFIER | BACKQUOTED_IDENT => in.lookaheadIn(BitSet(COLON, ARROW))
+        case _ => false
+      }
+    } && !in.isSoftModifierInModifierPosition
 
     def isExprIntro: Boolean =
-      if (in.token == IMPLIED) in.lookaheadIn(BitSet(MATCH))
+      if (in.token == IMPLIED || in.token == GIVEN) in.lookaheadIn(BitSet(MATCH))
       else (canStartExpressionTokens.contains(in.token) && !in.isSoftModifierInModifierPosition)
 
     def isDefIntro(allowedMods: BitSet, excludedSoftModifiers: Set[TermName] = Set.empty): Boolean =
@@ -1293,7 +1297,7 @@ object Parsers {
         if (in.token == MATCH) impliedMatch(start, imods)
         else implicitClosure(start, location, imods)
       }
-      else if(in.token == IMPLIED) {
+      else if (in.token == IMPLIED || in.token == GIVEN) {
         in.nextToken()
         if (in.token == MATCH)
           impliedMatch(start, EmptyModifiers)
@@ -2359,12 +2363,12 @@ object Parsers {
 
     type ImportConstr = (Boolean, Tree, List[Tree]) => Tree
 
-    /** Import  ::= import [delegate] [ImportExpr {`,' ImportExpr}
-     *  Export  ::= export [delegate] [ImportExpr {`,' ImportExpr}
+    /** Import  ::= `import' [`given'] [ImportExpr {`,' ImportExpr}
+     *  Export  ::= `export' [`given'] [ImportExpr {`,' ImportExpr}
      */
     def importClause(leading: Token, mkTree: ImportConstr): List[Tree] = {
       val offset = accept(leading)
-      val importDelegate = in.token == IMPLIED
+      val importDelegate = in.token == IMPLIED || in.token == GIVEN
       if (importDelegate) in.nextToken()
       commaSeparated(importExpr(importDelegate, mkTree)) match {
         case t :: rest =>
@@ -2706,8 +2710,8 @@ object Parsers {
           objectDef(start, posMods(start, mods | Case | Module))
         case ENUM =>
           enumDef(start, posMods(start, mods | Enum))
-        case IMPLIED =>
-          instanceDef(start, mods, atSpan(in.skipToken()) { Mod.Delegate() })
+        case IMPLIED | GIVEN =>
+          instanceDef(in.token == GIVEN, start, mods, atSpan(in.skipToken()) { Mod.Delegate() })
         case _ =>
           syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
           EmptyTree
@@ -2804,12 +2808,12 @@ object Parsers {
      *  InstanceBody   ::=  [‘for’ ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
      *                   |  ‘for’ Type {GivenParamClause} ‘=’ Expr
      */
-    def instanceDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
+    def instanceDef(newStyle: Boolean, start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, instanceMod)
-      val name = if (isIdent) ident() else EmptyTermName
+      val name = if (isIdent && (!newStyle || in.name != nme.as)) ident() else EmptyTermName
       val tparams = typeParamClauseOpt(ParamOwner.Def)
       val parents =
-        if (in.token == FOR) {
+        if (!newStyle && in.token == FOR || newStyle && isIdent(nme.as)) {
           in.nextToken()
           tokenSeparated(COMMA, constrApp)
         }
@@ -3116,8 +3120,16 @@ object Parsers {
         setLastStatOffset()
         if (in.token == IMPORT)
           stats ++= importClause(IMPORT, Import)
-        else if (in.token == GIVEN)
-          stats += implicitClosure(in.offset, Location.InBlock, modifiers(closureMods))
+        else if (in.token == GIVEN) {
+          val start = in.offset
+          val mods = modifiers(closureMods)
+          mods.mods match {
+            case givenMod :: Nil if !isBindingIntro =>
+              stats += instanceDef(true, start, EmptyModifiers, Mod.Delegate().withSpan(givenMod.span))
+            case _ =>
+              stats += implicitClosure(in.offset, Location.InBlock, mods)
+          }
+        }
         else if (isExprIntro)
           stats += expr(Location.InBlock)
         else if (isDefIntro(localModifierTokens, excludedSoftModifiers = Set(nme.`opaque`)))

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

@@ -216,16 +216,14 @@ object Tokens extends TokensCommon {
     USCORE, NULL, THIS, SUPER, TRUE, FALSE, RETURN, QUOTEID, XMLSTART)
 
   final val canStartExpressionTokens: TokenSet = atomicExprTokens | BitSet(
-    LBRACE, LPAREN, QUOTE, IF, DO, WHILE, FOR, NEW, TRY, THROW, IMPLIED)
+    LBRACE, LPAREN, QUOTE, IF, DO, WHILE, FOR, NEW, TRY, THROW, IMPLIED, GIVEN)
 
   final val canStartTypeTokens: TokenSet = literalTokens | identifierTokens | BitSet(
     THIS, SUPER, USCORE, LPAREN, AT)
 
-  final val canStartBindingTokens: TokenSet = identifierTokens | BitSet(USCORE, LPAREN)
-
   final val templateIntroTokens: TokenSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
 
-  final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE, IMPLIED)
+  final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE, IMPLIED, GIVEN)
 
   final val defIntroTokens: TokenSet = templateIntroTokens | dclIntroTokens
 

docs/docs/reference/contextual/delegates.md

@@ -31,15 +31,15 @@ given ListOrd[T] as Ord[List[T]] given (ord: Ord[T]) {
   }
 }
 ```
-This code defines a trait `Ord` with two givens. `IntOrd` defines
+This code defines a trait `Ord` with two given instances. `IntOrd` defines
 a given for the type `Ord[Int]` whereas `ListOrd[T]` defines givens
 for `Ord[List[T]]` for all types `T` that come with a given instance for `Ord[T]` themselves.
 The `given (ord: Ord[T])` clause in `ListOrd` defines an implicit parameter.
 Given clauses are further explained in the [next section](./given-clauses.html).
 
 ## Anonymous Given Instances
 
-The name of a given instance can be left out. So the given definitions
+The name of a given instance can be left out. So the definitions
 of the last section can also be expressed like this:
 ```scala
 given as Ord[Int] { ... }

docs/docs/reference/contextual/import-delegate.md

@@ -18,7 +18,7 @@ object B {
 In the code above, the `import A._` clause of object `B` will import all members
 of `A` _except_ the given instance `tc`. Conversely, the second import `import given A._` will import _only_ that given instance.
 
-Generally, a normal import clause brings all definitions except given instances into scope whereas a `given` import brings only given instances into scope.
+Generally, a normal import clause brings definitions other than given instances into scope whereas a `given` import brings only given instances into scope.
 
 There are two main benefits arising from these rules:
 
@@ -62,7 +62,7 @@ would import `im`, `intOrd`, and `listOrd` but leave out `ec`. By-type imports c
 
 The rules for imports given above have the consequence that a library
 would have to migrate in lockstep with all its users from old style implicits and
-normal imports to given definitions and imports.
+normal imports to given instances and imports.
 
 The following modifications avoid this hurdle to migration.
 

tests/neg/i5978.scala

@@ -5,10 +5,10 @@ opaque type Position[Buffer] = Int
 trait TokenParser[Token, R]
 
 object TextParser {
-  delegate TP for TokenParser[Char, Position[CharSequence]] {}
+  given TP as TokenParser[Char, Position[CharSequence]] {}
 
-  delegate FromCharToken for Conversion[Char, Position[CharSequence]]
-    given (T: TokenParser[Char, Position[CharSequence]])  = ???
+  given FromCharToken as Conversion[Char, Position[CharSequence]]
+    given (T: TokenParser[Char, Position[CharSequence]]) = ???
 }
 
 
@@ -22,7 +22,7 @@ object Testcase {
     val co_x : Position[CharSequence] = 'x'                   // error
 
     {
-      delegate XXX for Conversion[Char, Position[CharSequence]] = co_i
+      given XXX as Conversion[Char, Position[CharSequence]] = co_i
       val co_y : Position[CharSequence] = 'x'
     }
   }

tests/pos/i5978.scala

@@ -7,16 +7,15 @@ trait TokenParser[Token, R]
 package p1 {
 
   object TextParser {
-    delegate TP for TokenParser[Char, Position[CharSequence]] {}
+    given TP as TokenParser[Char, Position[CharSequence]] {}
 
-    delegate FromCharToken for Conversion[Char, Position[CharSequence]]
-      given (T: TokenParser[Char, Position[CharSequence]])= ???
+    given FromCharToken as Conversion[Char, Position[CharSequence]]
+      given (T: TokenParser[Char, Position[CharSequence]]) = ???
   }
 
-
   object Testcase {
     def main(args: Array[String]): Unit = {
-      import delegate TextParser._
+      import given TextParser._
       import TextParser._
 
       val tp_v: TokenParser[Char, Position[CharSequence]] = TextParser.TP
@@ -25,7 +24,7 @@ package p1 {
       val co_x : Position[CharSequence] = 'x'
 
       {
-        delegate XXX for Conversion[Char, Position[CharSequence]] = co_i
+        given XXX as Conversion[Char, Position[CharSequence]] = co_i
         val co_y : Position[CharSequence] = 'x'
       }
     }
@@ -42,7 +41,7 @@ package p2 {
   object Testcase {
     def main(args: Array[String]): Unit = {
       import TextParser._
-      import delegate TextParser._
+      import given TextParser._
 
       val tp_v: TokenParser[Char, Position[CharSequence]] = TextParser.TP
       val tp_i = the[TokenParser[Char, Position[CharSequence]]]
@@ -60,19 +59,19 @@ package p3 {
 
   object Testcase {
     def main(args: Array[String]): Unit = {
-      import delegate TextParser._
+      import given TextParser._
       import TextParser._
 
       val co_i: Conversion[Char, Position[CharSequence]] = the[Conversion[Char, Position[CharSequence]]]
 
       {
         val tp_v: TokenParser[Char, Position[CharSequence]] = TextParser.TP
         val tp_i = the[TokenParser[Char, Position[CharSequence]]]
-        delegate for Conversion[Char, Position[CharSequence]] = co_i
+        given as Conversion[Char, Position[CharSequence]] = co_i
         val co_x : Position[CharSequence] = 'x'
 
         {
-          delegate XXX for Conversion[Char, Position[CharSequence]] = co_i
+          given XXX as Conversion[Char, Position[CharSequence]] = co_i
           val co_y : Position[CharSequence] = 'x'
         }
       }