Remove label-defs.

Now that nothing in the compiler generates label-defs anymore, we
can completely get rid of them.

Since `Labeled` blocks do not exist in Tasty, the `LABEL` flag
disappears from Tasty altogether.

Author: sjrd

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -81,7 +81,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   type ArrayValue      = tpd.JavaSeqLiteral
   type ApplyDynamic    = Null
   type ModuleDef       = Null
-  type LabelDef        = tpd.DefDef
+  type LabelDef        = Null
   type Closure         = tpd.Closure
 
   val NoSymbol = Symbols.NoSymbol
@@ -400,7 +400,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
   def emitAsmp: Option[String] = None
 
-  def shouldEmitJumpAfterLabels = true
+  def hasLabelDefs = false
 
   def dumpClasses: Option[String] =
     if (ctx.settings.Ydumpclasses.isDefault) None
@@ -457,26 +457,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     if (found == null) None else Some(found)
   }
 
-  def getLabelDefOwners(tree: Tree): Map[Tree, List[LabelDef]] = {
-    // for each rhs of a defdef returns LabelDefs inside this DefDef
-    val res = new collection.mutable.HashMap[Tree, List[LabelDef]]()
-
-    val t = new TreeTraverser {
-      var outerRhs: Tree = tree
-
-      def traverse(tree: tpd.Tree)(implicit ctx: Context): Unit = tree match {
-        case t: DefDef =>
-          if (t.symbol is Flags.Label)
-            res.put(outerRhs, t :: res.getOrElse(outerRhs, Nil))
-          else outerRhs = t
-          traverseChildren(t)
-        case _ => traverseChildren(tree)
-      }
-    }
-
-    t.traverse(tree)
-    res.toMap
-  }
+  def getLabelDefOwners(tree: Tree): Map[Tree, List[LabelDef]] = Map.empty
 
   // todo: remove
   def isMaybeBoxed(sym: Symbol) = {
@@ -947,9 +928,6 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
           }
         case Types.ClassInfo(_, sym, _, _, _)           => primitiveOrClassToBType(sym) // We get here, for example, for genLoadModule, which invokes toTypeKind(moduleClassSymbol.info)
 
-        case t: MethodType => // triggers for LabelDefs
-          t.resultType.toTypeKind(ct)(storage)
-
         /* AnnotatedType should (probably) be eliminated by erasure. However we know it happens for
          * meta-annotated annotations (@(ann @getter) val x = 0), so we don't emit a warning.
          * The type in the AnnotationInfo is an AnnotatedTpe. Tested in jvm/annotations.scala.
@@ -1117,15 +1095,9 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   object LabelDef extends LabelDeconstructor {
-    def _1: Name = field.name
-    def _2: List[Symbol] = field.vparamss.flatMap(_.map(_.symbol))
-    def _3: Tree = field.rhs
-
-    override def unapply(s: LabelDef): DottyBackendInterface.this.LabelDef.type = {
-      if (s.symbol is Flags.Label) this.field = s
-      else this.field = null
-      this
-    }
+    def _1: Name = ???
+    def _2: List[Symbol] = ???
+    def _3: Tree = ???
   }
 
   object Typed extends TypedDeconstrutor {

compiler/src/dotty/tools/backend/jvm/LabelDefs.scala

@@ -14,7 +14,7 @@ import transform._
 import util.FreshNameCreator
 import core.DenotTransformers.DenotTransformer
 import core.Denotations.SingleDenotation
-import dotty.tools.backend.jvm.{CollectSuperCalls, GenBCode, LabelDefs}
+import dotty.tools.backend.jvm.{CollectSuperCalls, GenBCode}
 import dotty.tools.dotc.transform.localopt.StringInterpolatorOpt
 
 /** The central class of the dotc compiler. The job of a compiler is to create
@@ -117,8 +117,7 @@ class Compiler {
          new RestoreScopes,          // Repair scopes rendered invalid by moving definitions in prior phases of the group
          new SelectStatic,           // get rid of selects that would be compiled into GetStatic
          new CollectEntryPoints,     // Find classes with main methods
-         new CollectSuperCalls,      // Find classes that are called with super
-         new LabelDefs) ::           // Converts calls to labels to jumps
+         new CollectSuperCalls) ::   // Find classes that are called with super
     Nil
 
   /** Generate the output of the compilation */

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -291,7 +291,7 @@ object Flags {
   final val Covariant = typeFlag(20, "<covariant>")
   final val OuterAccessor = termFlag(20, "<outer accessor>")
 
-  /** A contravariant type variable / a label method */
+  /** A contravariant type variable / the label of a labeled block */
   final val ContravariantOrLabel = commonFlag(21, "")
   final val Contravariant = typeFlag(21, "<contravariant>")
   final val Label = termFlag(21, "<label>")
@@ -575,9 +575,6 @@ object Flags {
   /** A lazy or deferred value */
   final val LazyOrDeferred = Lazy | Deferred
 
-  /** An accessor or label */
-  final val AccessorOrLabel = Accessor | Label
-
   /** An accessor or a synthetic symbol */
   final val AccessorOrSynthetic = Accessor | Synthetic
 

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

@@ -4,7 +4,7 @@ package core
 
 import Periods._
 import Contexts._
-import dotty.tools.backend.jvm.{LabelDefs, GenBCode}
+import dotty.tools.backend.jvm.GenBCode
 import dotty.tools.dotc.core.Symbols.ClassSymbol
 import util.DotClass
 import DenotTransformers._
@@ -331,7 +331,6 @@ object Phases {
     private[this] var myErasedTypes = false
     private[this] var myFlatClasses = false
     private[this] var myRefChecked = false
-    private[this] var myLabelsReordered = false
 
     private[this] var mySameMembersStartId = NoPhaseId
     private[this] var mySameParentsStartId = NoPhaseId
@@ -349,7 +348,6 @@ object Phases {
     final def erasedTypes = myErasedTypes   // Phase is after erasure
     final def flatClasses = myFlatClasses   // Phase is after flatten
     final def refChecked = myRefChecked     // Phase is after RefChecks
-    final def labelsReordered = myLabelsReordered // Phase is after LabelDefs, labels are flattened and owner chains don't mirror this
 
     final def sameMembersStartId = mySameMembersStartId
       // id of first phase where all symbols are guaranteed to have the same members as in this phase
@@ -365,7 +363,6 @@ object Phases {
       myErasedTypes  = prev.getClass == classOf[Erasure]      || prev.erasedTypes
       myFlatClasses  = prev.getClass == classOf[Flatten]      || prev.flatClasses
       myRefChecked   = prev.getClass == classOf[RefChecks]    || prev.refChecked
-      myLabelsReordered = prev.getClass == classOf[LabelDefs] || prev.labelsReordered
       mySameMembersStartId = if (changesMembers) id else prev.sameMembersStartId
       mySameParentsStartId = if (changesParents) id else prev.sameParentsStartId
     }

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

@@ -601,12 +601,11 @@ object SymDenotations {
 
     /** Is this a "real" method? A real method is a method which is:
      *  - not an accessor
-     *  - not a label
      *  - not an anonymous function
      *  - not a companion method
      */
     final def isRealMethod(implicit ctx: Context) =
-      this.is(Method, butNot = AccessorOrLabel) &&
+      this.is(Method, butNot = Accessor) &&
         !isAnonymousFunction &&
         !isCompanionMethod
 
@@ -770,12 +769,11 @@ object SymDenotations {
 
     /** Symbol is an owner that would be skipped by effectiveOwner. Skipped are
      *   - package objects
-     *   - labels
      *   - non-lazy valdefs
      */
     def isWeakOwner(implicit ctx: Context): Boolean =
       isPackageObject ||
-      isTerm && !is(MethodOrLazy, butNot = Label) && !isLocalDummy
+      isTerm && !is(MethodOrLazy) && !isLocalDummy
 
     def isSkolem: Boolean = name == nme.SKOLEM
 
@@ -885,7 +883,7 @@ object SymDenotations {
     final def skipWeakOwner(implicit ctx: Context): Symbol =
       if (isWeakOwner) owner.skipWeakOwner else symbol
 
-    /** The owner, skipping package objects, labels and non-lazy valdefs. */
+    /** The owner, skipping package objects and non-lazy valdefs. */
     final def effectiveOwner(implicit ctx: Context) = owner.skipWeakOwner
 
     /** The class containing this denotation.
@@ -930,7 +928,7 @@ object SymDenotations {
      *  A local dummy owner is mapped to the primary constructor of the class.
      */
     final def enclosingMethod(implicit ctx: Context): Symbol =
-      if (this is (Method, butNot = Label)) symbol
+      if (this.is(Method)) symbol
       else if (this.isClass) primaryConstructor
       else if (this.exists) owner.enclosingMethod
       else NoSymbol

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

@@ -183,7 +183,7 @@ object TypeErasure {
     if (defn.isPolymorphicAfterErasure(sym)) eraseParamBounds(sym.info.asInstanceOf[PolyType])
     else if (sym.isAbstractType) TypeAlias(WildcardType)
     else if (sym.isConstructor) outer.addParam(sym.owner.asClass, erase(tp)(erasureCtx))
-    else if (sym.is(Label, butNot = Method)) erase.eraseResult(sym.info)(erasureCtx)
+    else if (sym.is(Label)) erase.eraseResult(sym.info)(erasureCtx)
     else erase.eraseInfo(tp, sym)(erasureCtx) match {
       case einfo: MethodType =>
         if (sym.isGetter && einfo.resultType.isRef(defn.UnitClass))

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

@@ -194,7 +194,6 @@ Standard-Section: "ASTs" TopLevelStat*
                   SYNTHETIC                           // generated by Scala compiler
                   ARTIFACT                            // to be tagged Java Synthetic
                   MUTABLE                             // a var
-                  LABEL                               // method generated as a label
                   FIELDaccessor                       // getter or setter
                   CASEaccessor                        // getter for case class param
                   COVARIANT                           // type parameter marked “+”
@@ -246,7 +245,7 @@ Standard Section: "Comments" Comment*
 object TastyFormat {
 
   final val header = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion = 11
+  val MajorVersion = 12
   val MinorVersion = 0
 
   /** Tags used to serialize names */
@@ -309,19 +308,18 @@ object TastyFormat {
   final val SYNTHETIC = 23
   final val ARTIFACT = 24
   final val MUTABLE = 25
-  final val LABEL = 26
-  final val FIELDaccessor = 27
-  final val CASEaccessor = 28
-  final val COVARIANT = 29
-  final val CONTRAVARIANT = 30
-  final val SCALA2X = 31
-  final val DEFAULTparameterized = 32
-  final val STABLE = 33
-  final val MACRO = 34
-  final val ERASED = 35
-  final val PARAMsetter = 36
-  final val EMPTYTREE = 37
-  final val EMPTYTYPETREE = 38
+  final val FIELDaccessor = 26
+  final val CASEaccessor = 27
+  final val COVARIANT = 28
+  final val CONTRAVARIANT = 29
+  final val SCALA2X = 30
+  final val DEFAULTparameterized = 33
+  final val STABLE = 34
+  final val MACRO = 35
+  final val ERASED = 36
+  final val PARAMsetter = 37
+  final val EMPTYTREE = 38
+  final val EMPTYTYPETREE = 39
 
   // Cat. 2:    tag Nat
 
@@ -491,7 +489,6 @@ object TastyFormat {
        | SYNTHETIC
        | ARTIFACT
        | MUTABLE
-       | LABEL
        | FIELDaccessor
        | CASEaccessor
        | COVARIANT
@@ -548,7 +545,6 @@ object TastyFormat {
     case SYNTHETIC => "SYNTHETIC"
     case ARTIFACT => "ARTIFACT"
     case MUTABLE => "MUTABLE"
-    case LABEL => "LABEL"
     case FIELDaccessor => "FIELDaccessor"
     case CASEaccessor => "CASEaccessor"
     case COVARIANT => "COVARIANT"

compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala

@@ -639,7 +639,7 @@ class TreePickler(pickler: TastyPickler) {
       if (flags is DefaultParameterized) writeByte(DEFAULTparameterized)
       if (flags is Stable) writeByte(STABLE)
       if (flags is ParamAccessor) writeByte(PARAMsetter)
-      if (flags is Label) writeByte(LABEL)
+      assert(!(flags is Label))
     } else {
       if (flags is Sealed) writeByte(SEALED)
       if (flags is Abstract) writeByte(ABSTRACT)