Syntax and parsing for derives clauses

Author: odersky

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

@@ -649,8 +649,8 @@ object Parsers {
 
     /** QualId ::= id {`.' id}
     */
-    def qualId(): Tree =
-      dotSelectors(termIdent())
+    val qualId: () => Tree =
+      () => dotSelectors(termIdent())
 
     /** SimpleExpr    ::= literal
      *                  | symbol
@@ -2437,7 +2437,7 @@ object Parsers {
       finalizeDef(ModuleDef(name, templ), mods, start)
     }
 
-    /**  EnumDef ::=  id ClassConstr [`extends' ConstrApps] EnumBody
+    /**  EnumDef ::=  id ClassConstr InheritClauses EnumBody
      */
     def enumDef(start: Offset, mods: Modifiers, enumMod: Mod): TypeDef = atSpan(start, nameStart) {
       val modName = ident()
@@ -2518,15 +2518,32 @@ object Parsers {
       t :: ts
     }
 
-    /** Template          ::=  [‘extends’ ConstrApps] [TemplateBody]
+    /** InheritClauses ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
      */
-    def template(constr: DefDef, isEnum: Boolean = false): Template = {
-      val parents =
+    def inheritClauses(): (List[Tree], List[Tree]) = {
+      val extended =
         if (in.token == EXTENDS) {
           in.nextToken()
-          constrApps()
+          if (in.token == LBRACE) {
+            in.errorOrMigrationWarning("`extends' must be followed by at least one parent")
+            Nil
+          }
+          else constrApps()
+        }
+        else Nil
+      val derived =
+        if (in.token == DERIVES) {
+          in.nextToken()
+          tokenSeparated(COMMA, qualId)
         }
         else Nil
+      (extended, derived)
+    }
+
+    /** Template          ::=  InheritClauses [TemplateBody]
+     */
+    def template(constr: DefDef, isEnum: Boolean = false): Template = {
+      val (parents, deriveds) = inheritClauses()
       newLineOptWhenFollowedBy(LBRACE)
       if (isEnum && in.token != LBRACE)
         syntaxErrorOrIncomplete(ExpectedTokenButFound(LBRACE, in.token))
@@ -2537,7 +2554,7 @@ object Parsers {
      */
     def templateOpt(constr: DefDef, isEnum: Boolean = false): Template = {
       newLineOptWhenFollowedBy(LBRACE)
-      if (in.token == EXTENDS || in.token == LBRACE)
+      if (in.token == EXTENDS || in.token == DERIVES || in.token == LBRACE)
         template(constr, isEnum)
       else
         Template(constr, Nil, EmptyValDef, Nil)

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

@@ -205,7 +205,8 @@ object Scanners {
     private def handleMigration(keyword: Token): Token =
       if (!isScala2Mode) keyword
       else if (  keyword == ENUM
-              || keyword == ERASED) treatAsIdent()
+              || keyword == ERASED
+              || keyword == DERIVES) treatAsIdent()
       else keyword
 
 

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

@@ -94,6 +94,7 @@ abstract class TokensCommon {
   //final val FORSOME = 61;          enter(FORSOME, "forSome") // TODO: deprecate
   //final val ENUM = 62;             enter(ENUM, "enum")
   //final val ERASED = 63;           enter(ERASED, "erased")
+  //final val DERIVES = 64;          enter(DERIVES, "derives")
 
   /** special symbols */
   final val COMMA = 70;            enter(COMMA, "','")
@@ -178,6 +179,7 @@ object Tokens extends TokensCommon {
   final val FORSOME = 61;          enter(FORSOME, "forSome") // TODO: deprecate
   final val ENUM = 62;             enter(ENUM, "enum")
   final val ERASED = 63;           enter(ERASED, "erased")
+  final val DERIVES = 64;          enter(DERIVES, "derives")
 
   /** special symbols */
   final val NEWLINE = 78;          enter(NEWLINE, "end of statement", "new line")
@@ -198,7 +200,7 @@ object Tokens extends TokensCommon {
   /** XML mode */
   final val XMLSTART = 96;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
 
-  final val alphaKeywords: TokenSet = tokenRange(IF, ERASED)
+  final val alphaKeywords: TokenSet = tokenRange(IF, DERIVES)
   final val symbolicKeywords: TokenSet = tokenRange(USCORE, VIEWBOUND)
   final val symbolicTokens: TokenSet = tokenRange(COMMA, VIEWBOUND)
   final val keywords: TokenSet = alphaKeywords | symbolicKeywords

docs/docs/internals/syntax.md

@@ -345,8 +345,9 @@ ClassDef          ::=  id ClassConstr [Template]
 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 [‘extends’ ConstrApps] EnumBody           EnumDef(mods, name, tparams, template)
-Template          ::=  ConstrApps [TemplateBody] | TemplateBody                 Template(constr, parents, self, stats)
+EnumDef           ::=  id ClassConstr InheritClauses EnumBody                   EnumDef(mods, name, tparams, template)
+Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)
+InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
 ConstrApps        ::=  ConstrApp {‘with’ ConstrApp}
                     |  ConstrApp {‘,’ ConstrApp}
 ConstrApp         ::=  AnnotType {ArgumentExprs}                                Apply(tp, args)

tests/run/typeclass-derivation2.scala

@@ -108,8 +108,7 @@ object Deriving {
 }
 
 // An algebraic datatype
-enum Lst[+T] // derives Eq, Pickler
-{
+enum Lst[+T] derives Eq, Pickler, Show {
   case Cons(hd: T, tl: Lst[T])
   case Nil
 }
@@ -146,7 +145,7 @@ object Lst extends Deriving {
 }
 
 // A simple product type
-case class Pair[T](x: T, y: T) // derives Eq, Pickler
+case class Pair[T](x: T, y: T) derives Eq, Pickler
 
 object Pair extends Deriving {
   // common compiler-generated infrastructure