Simplify syntax

`enum' only allowed as a prefix of classes, dropped from traits and objects.

Author: odersky

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

@@ -912,7 +912,7 @@ object desugar {
         case (gen: GenFrom) :: (rest @ (GenFrom(_, _) :: _)) =>
           val cont = makeFor(mapName, flatMapName, rest, body)
           Apply(rhsSelect(gen, flatMapName), makeLambda(gen.pat, cont))
-        case (enum @ GenFrom(pat, rhs)) :: (rest @ GenAlias(_, _) :: _) =>
+        case (GenFrom(pat, rhs)) :: (rest @ GenAlias(_, _) :: _) =>
           val (valeqs, rest1) = rest.span(_.isInstanceOf[GenAlias])
           val pats = valeqs map { case GenAlias(pat, _) => pat }
           val rhss = valeqs map { case GenAlias(_, rhs) => rhs }
@@ -1013,7 +1013,6 @@ object desugar {
               List(CaseDef(Ident(nme.DEFAULT_EXCEPTION_NAME), EmptyTree, Apply(handler, Ident(nme.DEFAULT_EXCEPTION_NAME)))),
               finalizer)
         }
-
     }
   }.withPos(tree.pos)
 

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

@@ -829,11 +829,11 @@ object JavaParsers {
       val superclazz = Apply(TypeApply(
         Select(New(javaLangDot(tpnme.Enum)), nme.CONSTRUCTOR), List(enumType)),
         List(Literal(Constant(null)),Literal(Constant(0))))
-      val enum = atPos(start, nameOffset) {
+      val enumclazz = atPos(start, nameOffset) {
         TypeDef(name,
           makeTemplate(superclazz :: interfaces, body, List(), true)).withMods(mods | Flags.Enum)
       }
-      addCompanionObject(consts ::: statics ::: predefs, enum)
+      addCompanionObject(consts ::: statics ::: predefs, enumclazz)
     }
 
     def enumConst(enumType: Tree) = {

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

@@ -2032,8 +2032,8 @@ object Parsers {
       }
     }
 
-    /** TmplDef ::=  ([`case' | `enum]'] ‘class’ | [`enum'] trait’) ClassDef
-     *            |  [`case' | `enum'] `object' ObjectDef
+    /** TmplDef ::=  ([`case' | `enum]'] ‘class’ | trait’) ClassDef
+     *            |  [`case'] `object' ObjectDef
      *            |  `enum' EnumDef
      */
     def tmplDef(start: Int, mods: Modifiers): Tree = {
@@ -2050,10 +2050,7 @@ object Parsers {
           objectDef(start, posMods(start, mods | Case | Module))
         case ENUM =>
           val mods1 = addMod(mods, atPos(in.skipToken()) { Mod.Enum() })
-          in.token match {
-            case CLASS | TRAIT | OBJECT => tmplDef(start, mods1)
-            case _ => enumDef(start, mods)
-          }
+          if (in.token == CLASS) tmplDef(start, mods1) else enumDef(start, mods)
         case _ =>
           syntaxErrorOrIncomplete("expected start of definition")
           EmptyTree

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

@@ -294,7 +294,10 @@ object Scanners {
         if (!sepRegions.isEmpty && sepRegions.head == lastToken)
           sepRegions = sepRegions.tail
       case ARROW =>
-        if (!sepRegions.isEmpty && sepRegions.head == lastToken)
+        if (!sepRegions.isEmpty && sepRegions.head == ARROW)
+          sepRegions = sepRegions.tail
+      case EXTENDS =>
+        if (!sepRegions.isEmpty && sepRegions.head == ARROW)
           sepRegions = sepRegions.tail
       case STRINGLIT =>
         if (inMultiLineInterpolation)
@@ -330,7 +333,8 @@ object Scanners {
       if (isAfterLineEnd() &&
           (canEndStatTokens contains lastToken) &&
           (canStartStatTokens contains token) &&
-          (sepRegions.isEmpty || sepRegions.head == RBRACE)) {
+          (sepRegions.isEmpty || sepRegions.head == RBRACE ||
+           sepRegions.head == ARROW && token == CASE)) {
         next copyFrom this
         //  todo: make offset line-end of previous line?
         offset = if (lineStartOffset <= offset) lineStartOffset else lastLineStartOffset

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

@@ -192,7 +192,7 @@ object Tokens extends TokensCommon {
   /** XML mode */
   final val XMLSTART = 96;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
 
-  final val alphaKeywords = tokenRange(IF, INLINE)
+  final val alphaKeywords = tokenRange(IF, ENUM)
   final val symbolicKeywords = tokenRange(USCORE, VIEWBOUND)
   final val symbolicTokens = tokenRange(COMMA, VIEWBOUND)
   final val keywords = alphaKeywords | symbolicKeywords
@@ -213,7 +213,7 @@ object Tokens extends TokensCommon {
 
   final val canStartBindingTokens = identifierTokens | BitSet(USCORE, LPAREN)
 
-  final val templateIntroTokens = BitSet(CLASS, TRAIT, OBJECT, CASECLASS, CASEOBJECT)
+  final val templateIntroTokens = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
 
   final val dclIntroTokens = BitSet(DEF, VAL, VAR, TYPE)
 

docs/docs/internals/syntax.md

@@ -330,15 +330,15 @@ DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr
                     |  ‘this’ DefParamClause DefParamClauses                    DefDef(_, <init>, Nil, vparamss, EmptyTree, expr | Block)
                        (‘=’ ConstrExpr | [nl] ConstrBlock)
 
-TmplDef           ::=  ([‘case’ | `enum'] ‘class’ | [`enum'] trait’) ClassDef
-                    |  [‘case’ | `enum'] ‘object’ ObjectDef
+TmplDef           ::=  ([‘case’ | `enum'] ‘class’ | trait’) ClassDef
+                    |  [‘case’] ‘object’ ObjectDef
                     |  `enum' EnumDef
 ClassDef          ::=  id ClassConstr TemplateOpt                               ClassDef(mods, name, tparams, templ)
 ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses         with DefDef(_, <init>, Nil, vparamss, EmptyTree, EmptyTree) as first stat
 ConstrMods        ::=  AccessModifier
                     |  Annotation {Annotation} (AccessModifier | ‘this’)
 ObjectDef         ::=  id TemplateOpt                                           ModuleDef(mods, name, template)  // no constructor
-EnumDef           ::=  id ClassConstr [`extends' [ConstrApps]]                  EnumDef(mods, name, tparams, template)               
+EnumDef           ::=  id ClassConstr [`extends' [ConstrApps]]                  EnumDef(mods, name, tparams, template)
                        [nl] ‘{’ EnumCaseStat {semi EnumCaseStat ‘}’
 EnumCaseStat      ::=  {Annotation [nl]} {Modifier} EnumCase
 EnumCase          ::=  `case' (EnumClassDef | ObjectDef)