Go back to given ... as for instances

Author: odersky

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

@@ -412,6 +412,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

@@ -344,6 +344,15 @@ object Parsers {
       offset
     }
 
+    def accept(name: Name): Int = {
+      val offset = in.offset
+      if !isIdent(name) then
+        syntaxErrorOrIncomplete(em"`$name` expected")
+      if isIdent(name) then
+        in.nextToken()
+      offset
+    }
+
     def reportMissing(expected: Token): Unit =
       syntaxError(ExpectedTokenButFound(expected, in.token))
 
@@ -932,7 +941,7 @@ object Parsers {
       if lookahead.token == COLON then
         lookahead.nextToken()
         !lookahead.isAfterLineEnd
-      else lookahead.token == SUBTYPE
+      else lookahead.token == SUBTYPE || lookahead.isIdent(nme.as)
 
     def followingIsExtension() =
       val lookahead = in.LookaheadScanner()
@@ -3404,9 +3413,9 @@ object Parsers {
         syntaxError(i"extension clause can only define methods", stat.span)
     }
 
-    /** GivenDef       ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
-     *                   |  [GivenSig ‘:’] ConstrApps [TemplateBody]
-     *  GivenSig       ::=  [id] [DefTypeParamClause] {GivenParamClause}
+    /** GivenDef       ::=  [GivenSig] [‘_’ ‘<:’] Type ‘=’ Expr
+     *                   |  [GivenSig] ConstrApps [TemplateBody]
+     *  GivenSig       ::=  [id] [DefTypeParamClause] {GivenParamClause} ‘as’
      *  ExtParamClause ::=  [DefTypeParamClause] DefParamClause
      *  ExtMethods     ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
      */
@@ -3433,7 +3442,7 @@ object Parsers {
           templ.body.foreach(checkExtensionMethod(tparams, _))
           ModuleDef(name, templ)
         else
-          val hasLabel = !name.isEmpty && in.token == COLON
+          val hasLabel = !name.isEmpty && in.token == COLON || in.isIdent(nme.as)
           if hasLabel then in.nextToken()
           val tparams = typeParamClauseOpt(ParamOwner.Def)
           val paramsStart = in.offset
@@ -3446,17 +3455,21 @@ object Parsers {
               if !vparam.mods.is(Given) then syntaxError(em"$what must be `given`", vparam.span)))
           checkAllGivens(vparamss, "parameter of given instance")
           val parents =
-            if hasLabel then
-              constrApps(commaOK = true, templateCanFollow = true)
-            else if in.token == SUBTYPE then
+            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 !(name.isEmpty && tparams.isEmpty && vparamss.isEmpty) then
-                accept(COLON)
-              constrApps(commaOK = true, templateCanFollow = true)
+              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()

docs/blog/_posts/2019-11-04-20th-dotty-milestone-release.md

@@ -96,12 +96,15 @@ It is now possible to specialize `inline given`s with the help of `<:` as follow
 trait A
 class B extends A
 
-inline given tc <: A = B()
+inline given wb as _ <: A = B()
 
 val x: B = summon[A]
 ```
-
-This change brings `given`s even with the ordinary `inline def`s.
+In this example, the inline given `wb` will return a result of a subtype of the declared upper bound `A` as determined by `B`. In our terminology, `wb` is a whitebox macro. Contrast with the following definition of a blackbox given macro `bb`:
+```
+inline given bb as A = B()
+```
+Here, the type of `bb` will always be `A`, no matter what `B` returns.
 
 ## Normal parameters can follow `given` parameters
 Previously normal parameters after `given` parameter was disallowed mainly because they looked awkward with the old syntax. With the syntax being improved, this restriction is now lifted and you can write, e.g., the following program:

docs/docs/internals/syntax.md

@@ -384,9 +384,9 @@ 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)
-GivenDef          ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
-                    |  [GivenSig ‘:’] ConstrApps [TemplateBody]
-GivenSig          ::=  [id] [DefTypeParamClause] {GivenParamClause}
+GivenDef          ::=  [GivenSig] [‘_’ ‘<:’] Type ‘=’ Expr
+                    |  [GivenSig] ConstrApps [TemplateBody]
+GivenSig          ::=  [id] [DefTypeParamClause] {GivenParamClause} ‘as’
 ExtensionDef      ::=  [id] ‘on’ ExtParamClause {GivenParamClause} ExtMethods
 ExtMethods        ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’

docs/docs/reference/contextual/implicit-function-types.md

@@ -83,13 +83,13 @@ with implicit function types as parameters to avoid the plumbing boilerplate
 that would otherwise be necessary.
 ```scala
   def table(init: (given Table) => Unit) = {
-    given t: Table
+    given t as Table
     init
     t
   }
 
   def row(init: (given Row) => Unit)(given t: Table) = {
-    given r: Row
+    given r as Row
     init
     t.add(r)
   }

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

@@ -7,7 +7,7 @@ A special form of import wildcard selector is used to import given instances. Ex
 ```scala
 object A {
   class TC
-  given tc: TC
+  given tc as TC
   def f(given TC) = ???
 }
 object B {
@@ -50,8 +50,8 @@ Importing all given instances of a parameterized type is expressed by wildcard a
 For instance, assuming the object
 ```scala
 object Instances {
-  given intOrd: Ordering[Int]
-  given [T: Ordering] listOrd: Ordering[List[T]]
+  given intOrd as Ordering[Int]
+  given [T as Ordering] listOrd as Ordering[List[T]]
   given ec: ExecutionContext = ...
   given im: Monoid[Int]
 }

library/src/scala/IArray.scala

@@ -8,7 +8,7 @@ object opaques
   opaque type IArray[+T] = Array[_ <: T]
 
   /** Defines extension methods for immutable arrays */
-  given arrayOps: Object with
+  given arrayOps: Object {
 
     /** The selection operation on an immutable array.
       *
@@ -255,6 +255,7 @@ object opaques
       * If one of the two collections is longer than the other, its remaining elements are ignored. */
     def [T, U: ClassTag](arr: IArray[T]) zip(that: IArray[U]): IArray[(T, U)] =
       genericArrayOps(arr).zip(that).asInstanceOf[IArray[(T, U)]]
+  }
 end opaques
 
 type IArray[+T] = opaques.IArray[T]

tests/neg-custom-args/fatal-warnings/i7821.scala

@@ -3,7 +3,7 @@ object XObject {
 
   def anX: X = 5
 
-  given ops: Object {
+  given ops as Object {
     def (x: X) + (y: X): X = x + y
   }
 }
@@ -13,7 +13,7 @@ object MyXObject {
 
   def anX: MyX = XObject.anX
 
-  given ops: Object {
+  given ops as Object {
     def (x: MyX) + (y: MyX): MyX = x + y // error: warring: Infinite recursive call
   }
 }

tests/neg/exports.scala

@@ -5,7 +5,7 @@
     type PrinterType
     def print(bits: BitMap): Unit = ???
     def status: List[String] = ???
-    given bitmap : BitMap
+    given bitmap as BitMap
   }
 
   class Scanner {

tests/neg/i5978.scala

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