Change syntax.md to reflect new syntax

Author: odersky

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

@@ -1278,7 +1278,7 @@ object Parsers {
      *                      |  SimpleExpr1 ArgumentExprs `=' Expr
      *                      |  Expr2
      *                      |  [‘inline’] Expr2 `match' `{' CaseClauses `}'
-     *                      |  `delegate' `match' `{' ImplicitCaseClauses `}'
+     *                      |  `given' `match' `{' ImplicitCaseClauses `}'
      *  Bindings          ::=  `(' [Binding {`,' Binding}] `)'
      *  Binding           ::=  (id | `_') [`:' Type]
      *  Expr2             ::=  PostfixExpr [Ascription]
@@ -1482,7 +1482,7 @@ object Parsers {
      */
     def impliedMatch(start: Int, imods: Modifiers) = {
       def markFirstIllegal(mods: List[Mod]) = mods match {
-        case mod :: _ => syntaxError(em"illegal modifier for delegate match", mod.span)
+        case mod :: _ => syntaxError(em"illegal modifier for given match", mod.span)
         case _ =>
       }
       imods.mods match {
@@ -1497,7 +1497,7 @@ object Parsers {
           case pat => isVarPattern(pat)
         }
         if (!isImplicitPattern(pat))
-          syntaxError(em"not a legal pattern for a delegate match", pat.span)
+          syntaxError(em"not a legal pattern for a given match", pat.span)
       }
       result
     }
@@ -2396,7 +2396,7 @@ object Parsers {
           wildcardIdent() :: Nil
         case FOR =>
           if (!importDelegate)
-              syntaxError(em"`for` qualifier only allowed in `import delegate`")
+              syntaxError(em"`for` qualifier only allowed in `import given`")
           atSpan(in.skipToken()) {
             var t = infixType()
             while (in.token == COMMA) {
@@ -2695,7 +2695,7 @@ object Parsers {
     /** TmplDef ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
      *            |  [‘case’] ‘object’ ObjectDef
      *            |  ‘enum’ EnumDef
-     *            |  ‘instance’ InstanceDef
+     *            |  ‘given’ GivenDef
      */
     def tmplDef(start: Int, mods: Modifiers): Tree = {
       in.token match {
@@ -2804,10 +2804,9 @@ object Parsers {
       Template(constr, parents, Nil, EmptyValDef, Nil)
     }
 
-    /** InstanceDef    ::=  [id] [DefTypeParamClause] InstanceBody
-     *  InstanceParams ::=  [DefTypeParamClause] {GivenParamClause}
-     *  InstanceBody   ::=  [‘for’ ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
-     *                   |  ‘for’ Type {GivenParamClause} ‘=’ Expr
+    /** GivenDef          ::=  [id] [DefTypeParamClause] GivenBody
+     *  GivenBody         ::=  [‘as ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
+     *                      |  ‘as’ Type {GivenParamClause} ‘=’ Expr
      */
     def instanceDef(newStyle: Boolean, start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, instanceMod)

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -319,7 +319,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case _ => tree
     }
 
-    def importText(deleg: Boolean, expr: Tree, selectors: List[Tree]) = {
+    def importText(givenOnly: Boolean, expr: Tree, selectors: List[Tree]) = {
       def selectorText(sel: Tree): Text = sel match {
         case Thicket(l :: r :: Nil) => toTextGlobal(l) ~ " => " ~ toTextGlobal(r)
         case _: Ident => toTextGlobal(sel)
@@ -329,7 +329,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         case id :: Nil => toText(id)
         case _ => "{" ~ Text(selectors map selectorText, ", ") ~ "}"
       }
-      (keywordText("delegate ") provided deleg) ~
+      (keywordText("given ") provided givenOnly) ~
       toTextLocal(expr) ~ "." ~ selectorsText
     }
 

docs/docs/internals/syntax.md

@@ -92,20 +92,20 @@ semi             ::=  ‘;’ |  nl {nl}
 ### Regular keywords
 
 ```
-abstract  case      catch     class     def       delegate  do        else
-enum      export    extends   false     final     finally   for       given
-if        implicit  import    lazy      match     new       null      object
-package   private   protected override  return    super     sealed    then
-throw     trait     true      try       type      val       var       while
-with      yield
+abstract  case      catch     class     def       do        else      enum
+export    extends   false     final     finally   for       given     if
+implicit  import    lazy      match     new       null      object    package
+private   protected override  return    super     sealed    then      throw
+trait     true      try       type      val       var       while     with
+yield
 :         =         <-        =>        <:        :>        #         @
 =>>
 ```
 
 ### Soft keywords
 
 ```
-derives   inline    opaque
+as        derives   inline    opaque
 ~         *         |         &         +         -
 ```
 
@@ -203,7 +203,7 @@ Expr1             ::=  ‘if’ ‘(’ Expr ‘)’ {nl}
                     |  SimpleExpr1 ArgumentExprs ‘=’ Expr                       Assign(expr, expr)
                     |  Expr2
                     |  [‘inline’] Expr2 ‘match’ ‘{’ CaseClauses ‘}’             Match(expr, cases) -- point on match
-                    |  ‘implicit’ ‘match’ ‘{’ ImplicitCaseClauses ‘}’
+                    |  ‘given’ ‘match’ ‘{’ ImplicitCaseClauses ‘}’
 Expr2             ::=  PostfixExpr [Ascription]
 Ascription        ::=  ‘:’ InfixType                                            Typed(expr, tp)
                     |  ‘:’ Annotation {Annotation}                              Typed(expr, Annotated(EmptyTree, annot)*)
@@ -336,14 +336,14 @@ AccessQualifier   ::=  ‘[’ (id | ‘this’) ‘]’
 
 Annotation        ::=  ‘@’ SimpleType {ParArgumentExprs}                        Apply(tpe, args)
 
-Import            ::=  ‘import’ [‘delegate’] ImportExpr {‘,’ ImportExpr}
+Import            ::=  ‘import’ [‘given’] ImportExpr {‘,’ ImportExpr}
 ImportExpr        ::=  StableId ‘.’ (id | ‘_’ | ImportSelectors)                Import(expr, sels)
 ImportSelectors   ::=  ‘{’ {ImportSelector ‘,’} FinalSelector ‘}’
 FinalSelector     ::=  ImportSelector                                           Ident(name)
                     |  ‘_’                                                      Pair(id, id)
                     |  ‘for’ InfixType {‘,’ InfixType}                          TypeBoundsTree(EmptyTree, tpt)
 ImportSelector    ::=  id [‘=>’ id | ‘=>’ ‘_’]
-Export            ::=  ‘export’ [‘delegate’] ImportExpr {‘,’ ImportExpr}
+Export            ::=  ‘export’ [‘given’] ImportExpr {‘,’ ImportExpr}
 ```
 
 ### Declarations and Definitions
@@ -379,16 +379,16 @@ DefDef            ::=  DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr
 TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
                     |  [‘case’] ‘object’ ObjectDef
                     |  ‘enum’ EnumDef
-                    |  ‘delegate’ DelegateDef
+                    |  ‘given’ GivenDef
                     |  Export
 ClassDef          ::=  id ClassConstr [Template]                                ClassDef(mods, name, tparams, templ)
 ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses        with DefDef(_, <init>, Nil, vparamss, EmptyTree, EmptyTree) as first stat
 ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]                                            ModuleDef(mods, name, template)  // no constructor
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody                   EnumDef(mods, name, tparams, template)
-DelegateDef       ::=  [id] [DefTypeParamClause] DelegateBody
-DelegateBody      ::=  [‘for’ ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
-                    |  ‘for’ Type {GivenParamClause} ‘=’ Expr
+GivenDef          ::=  [id] [DefTypeParamClause] GivenBody
+GivenBody         ::=  [‘as ConstrApp {‘,’ ConstrApp }] {GivenParamClause} [TemplateBody]
+                    |  ‘as’ Type {GivenParamClause} ‘=’ Expr
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
 ConstrApps        ::=  ConstrApp {‘with’ ConstrApp}