Add "enum" construct

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

@@ -14,6 +14,7 @@ import reporting.diagnostic.messages._
 
 object desugar {
   import untpd._
+  import DesugarEnums._
 
   /** Tags a .withFilter call generated by desugaring a for expression.
    *  Such calls can alternatively be rewritten to use filter.
@@ -263,7 +264,9 @@ object desugar {
     val className = checkNotReservedName(cdef).asTypeName
     val impl @ Template(constr0, parents, self, _) = cdef.rhs
     val mods = cdef.mods
-    val companionMods = mods.withFlags((mods.flags & AccessFlags).toCommonFlags)
+    val companionMods = mods
+        .withFlags((mods.flags & AccessFlags).toCommonFlags)
+        .withMods(mods.mods.filter(!_.isInstanceOf[Mod.EnumCase]))
 
     val (constr1, defaultGetters) = defDef(constr0, isPrimaryConstructor = true) match {
       case meth: DefDef => (meth, Nil)
@@ -288,17 +291,31 @@ object desugar {
     }
 
     val isCaseClass = mods.is(Case) && !mods.is(Module)
+    val isEnum = mods.hasMod[Mod.Enum]
+    val isEnumCase = isLegalEnumCase(cdef)
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
       // This is not watertight, but `extends AnyVal` will be replaced by `inline` later.
 
-    val constrTparams = constr1.tparams map toDefParam
+    lazy val reconstitutedTypeParams = reconstitutedEnumTypeParams(cdef.pos.startPos)
+
+    val originalTparams =
+      if (isEnumCase && parents.isEmpty) {
+        if (constr1.tparams.nonEmpty) {
+          if (reconstitutedTypeParams.nonEmpty)
+            ctx.error(em"case with type parameters needs extends clause", constr1.tparams.head.pos)
+          constr1.tparams
+        }
+        else reconstitutedTypeParams
+      }
+      else constr1.tparams
+    val originalVparamss = constr1.vparamss
+    val constrTparams = originalTparams.map(toDefParam)
     val constrVparamss =
-      if (constr1.vparamss.isEmpty) { // ensure parameter list is non-empty
-        if (isCaseClass)
-          ctx.error(CaseClassMissingParamList(cdef), cdef.namePos)
+      if (originalVparamss.isEmpty) { // ensure parameter list is non-empty
+        if (isCaseClass) ctx.error(CaseClassMissingParamList(cdef), cdef.namePos)
         ListOfNil
       }
-      else constr1.vparamss.nestedMap(toDefParam)
+      else originalVparamss.nestedMap(toDefParam)
     val constr = cpy.DefDef(constr1)(tparams = constrTparams, vparamss = constrVparamss)
 
     // Add constructor type parameters and evidence implicit parameters
@@ -312,21 +329,24 @@ object desugar {
         stat
     }
 
-    val derivedTparams = constrTparams map derivedTypeParam
+    val derivedTparams =
+      if (isEnumCase) constrTparams else constrTparams map derivedTypeParam
     val derivedVparamss = constrVparamss nestedMap derivedTermParam
     val arity = constrVparamss.head.length
 
-    var classTycon: Tree = EmptyTree
+    val classTycon: Tree = new TypeRefTree // watching is set at end of method
 
-    // a reference to the class type, with all parameters given.
-    val classTypeRef/*: Tree*/ = {
-        // -language:keepUnions difference: classTypeRef needs type annotation, otherwise
-        // infers Ident | AppliedTypeTree, which
-        // renders the :\ in companions below untypable.
-      classTycon = (new TypeRefTree) withPos cdef.pos.startPos // watching is set at end of method
-      val tparams = impl.constr.tparams
-      if (tparams.isEmpty) classTycon else AppliedTypeTree(classTycon, tparams map refOfDef)
-    }
+    def appliedRef(tycon: Tree) =
+      (if (constrTparams.isEmpty) tycon
+       else AppliedTypeTree(tycon, constrTparams map refOfDef))
+       .withPos(cdef.pos.startPos)
+
+    // a reference to the class type bound by `cdef`, with type parameters coming from the constructor
+    val classTypeRef = appliedRef(classTycon)
+    // a reference to `enumClass`, with type parameters coming from the constructor
+    lazy val enumClassTypeRef =
+      if (reconstitutedTypeParams.isEmpty) enumClassRef
+      else appliedRef(enumClassRef)
 
     // new C[Ts](paramss)
     lazy val creatorExpr = New(classTypeRef, constrVparamss nestedMap refOfDef)
@@ -374,7 +394,9 @@ object desugar {
             DefDef(nme.copy, derivedTparams, copyFirstParams :: copyRestParamss, TypeTree(), creatorExpr)
               .withMods(synthetic) :: Nil
           }
-        copyMeths ::: productElemMeths.toList
+
+        val enumTagMeths = if (isEnumCase) enumTagMeth(CaseKind.Class)._1 :: Nil else Nil
+        copyMeths ::: enumTagMeths ::: productElemMeths.toList
       }
       else Nil
 
@@ -387,8 +409,12 @@ object desugar {
 
     // Case classes and case objects get a ProductN parent
     var parents1 = parents
+    if (isEnumCase && parents.isEmpty)
+      parents1 = enumClassTypeRef :: Nil
     if (mods.is(Case) && arity <= Definitions.MaxTupleArity)
-      parents1 = parents1 :+ productConstr(arity)
+      parents1 = parents1 :+ productConstr(arity) // TODO: This also adds Product0 to caes objects. Do we want that?
+    if (isEnum)
+      parents1 = parents1 :+ ref(defn.EnumType)
 
     // The thicket which is the desugared version of the companion object
     //     synthetic object C extends parentTpt { defs }
@@ -410,17 +436,26 @@ object desugar {
     // For all other classes, the parent is AnyRef.
     val companions =
       if (isCaseClass) {
+        // The return type of the `apply` method
+        val applyResultTpt =
+          if (isEnumCase)
+            if (parents.isEmpty) enumClassTypeRef
+            else parents.reduceLeft(AndTypeTree)
+          else TypeTree()
+
         val parent =
           if (constrTparams.nonEmpty ||
               constrVparamss.length > 1 ||
               mods.is(Abstract) ||
               constr.mods.is(Private)) anyRef
+          else
             // todo: also use anyRef if constructor has a dependent method type (or rule that out)!
-          else (constrVparamss :\ classTypeRef) ((vparams, restpe) => Function(vparams map (_.tpt), restpe))
+            (constrVparamss :\ (if (isEnumCase) applyResultTpt else classTypeRef)) (
+              (vparams, restpe) => Function(vparams map (_.tpt), restpe))
         val applyMeths =
           if (mods is Abstract) Nil
           else
-            DefDef(nme.apply, derivedTparams, derivedVparamss, TypeTree(), creatorExpr)
+            DefDef(nme.apply, derivedTparams, derivedVparamss, applyResultTpt, creatorExpr)
               .withFlags(Synthetic | (constr1.mods.flags & DefaultParameterized)) :: Nil
         val unapplyMeth = {
           val unapplyParam = makeSyntheticParameter(tpt = classTypeRef)
@@ -464,15 +499,15 @@ object desugar {
       else cpy.ValDef(self)(tpt = selfType).withMods(self.mods | SelfName)
     }
 
-    val cdef1 = {
-      val originalTparams = constr1.tparams.toIterator
-      val originalVparams = constr1.vparamss.toIterator.flatten
-      val tparamAccessors = derivedTparams.map(_.withMods(originalTparams.next.mods))
+    val cdef1 = addEnumFlags {
+      val originalTparamsIt = originalTparams.toIterator
+      val originalVparamsIt = originalVparamss.toIterator.flatten
+      val tparamAccessors = derivedTparams.map(_.withMods(originalTparamsIt.next.mods))
       val caseAccessor = if (isCaseClass) CaseAccessor else EmptyFlags
       val vparamAccessors = derivedVparamss match {
         case first :: rest =>
-          first.map(_.withMods(originalVparams.next.mods | caseAccessor)) ++
-          rest.flatten.map(_.withMods(originalVparams.next.mods))
+          first.map(_.withMods(originalVparamsIt.next.mods | caseAccessor)) ++
+          rest.flatten.map(_.withMods(originalVparamsIt.next.mods))
         case _ =>
           Nil
       }
@@ -503,23 +538,26 @@ object desugar {
    */
   def moduleDef(mdef: ModuleDef)(implicit ctx: Context): Tree = {
     val moduleName = checkNotReservedName(mdef).asTermName
-    val tmpl = mdef.impl
+    val impl = mdef.impl
     val mods = mdef.mods
+    lazy val isEnumCase = isLegalEnumCase(mdef)
     if (mods is Package)
-      PackageDef(Ident(moduleName), cpy.ModuleDef(mdef)(nme.PACKAGE, tmpl).withMods(mods &~ Package) :: Nil)
+      PackageDef(Ident(moduleName), cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
+    else if (isEnumCase)
+      expandEnumModule(moduleName, impl, mods, mdef.pos)
     else {
       val clsName = moduleName.moduleClassName
       val clsRef = Ident(clsName)
       val modul = ValDef(moduleName, clsRef, New(clsRef, Nil))
         .withMods(mods | ModuleCreationFlags | mods.flags & AccessFlags)
         .withPos(mdef.pos)
-      val ValDef(selfName, selfTpt, _) = tmpl.self
-      val selfMods = tmpl.self.mods
-      if (!selfTpt.isEmpty) ctx.error(ObjectMayNotHaveSelfType(mdef), tmpl.self.pos)
-      val clsSelf = ValDef(selfName, SingletonTypeTree(Ident(moduleName)), tmpl.self.rhs)
+      val ValDef(selfName, selfTpt, _) = impl.self
+      val selfMods = impl.self.mods
+      if (!selfTpt.isEmpty) ctx.error(ObjectMayNotHaveSelfType(mdef), impl.self.pos)
+      val clsSelf = ValDef(selfName, SingletonTypeTree(Ident(moduleName)), impl.self.rhs)
         .withMods(selfMods)
-        .withPos(tmpl.self.pos orElse tmpl.pos.startPos)
-      val clsTmpl = cpy.Template(tmpl)(self = clsSelf, body = tmpl.body)
+        .withPos(impl.self.pos orElse impl.pos.startPos)
+      val clsTmpl = cpy.Template(impl)(self = clsSelf, body = impl.body)
       val cls = TypeDef(clsName, clsTmpl)
         .withMods(mods.toTypeFlags & RetainedModuleClassFlags | ModuleClassCreationFlags)
       Thicket(modul, classDef(cls).withPos(mdef.pos))
@@ -542,11 +580,23 @@ object desugar {
   /**     val p1, ..., pN: T = E
    *  ==>
    *      makePatDef[[val p1: T1 = E]]; ...; makePatDef[[val pN: TN = E]]
+   *
+   *      case e1, ..., eN
+   *  ==>
+   *      expandSimpleEnumCase([case e1]); ...; expandSimpleEnumCase([case eN])
    */
-  def patDef(pdef: PatDef)(implicit ctx: Context): Tree = {
+  def patDef(pdef: PatDef)(implicit ctx: Context): Tree = flatTree {
     val PatDef(mods, pats, tpt, rhs) = pdef
-    val pats1 = if (tpt.isEmpty) pats else pats map (Typed(_, tpt))
-    flatTree(pats1 map (makePatDef(pdef, mods, _, rhs)))
+    if (mods.hasMod[Mod.EnumCase] && enumCaseIsLegal(pdef))
+      pats map {
+        case id: Ident =>
+          expandSimpleEnumCase(id.name.asTermName, mods,
+            Position(pdef.pos.start, id.pos.end, id.pos.start))
+    }
+    else {
+      val pats1 = if (tpt.isEmpty) pats else pats map (Typed(_, tpt))
+      pats1 map (makePatDef(pdef, mods, _, rhs))
+    }
   }
 
   /** If `pat` is a variable pattern,
@@ -923,7 +973,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 }
@@ -1024,7 +1074,6 @@ object desugar {
               List(CaseDef(Ident(nme.DEFAULT_EXCEPTION_NAME), EmptyTree, Apply(handler, Ident(nme.DEFAULT_EXCEPTION_NAME)))),
               finalizer)
         }
-
     }
   }.withPos(tree.pos)