diff --git a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index d1b4f2d52f68..b84814ea7a29 100644
--- a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -73,7 +73,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: Symbol = Symbols.NoSymbol
@@ -392,7 +392,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
   def emitAsmp: Option[String] = None
 
-  def shouldEmitJumpAfterLabels: Boolean = true
+  def hasLabelDefs: Boolean = false
 
   def dumpClasses: Option[String] =
     if (ctx.settings.Ydumpclasses.isDefault) None
@@ -449,26 +449,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): Boolean = {
@@ -939,9 +920,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.
@@ -1109,15 +1087,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): 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 {
diff --git a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
deleted file mode 100644
index 451ef95c288a..000000000000
--- a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
+++ /dev/null
@@ -1,120 +0,0 @@
-package dotty.tools.backend.jvm
-
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core.Contexts.Context
-import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.transform.MegaPhase._
-
-
-/**
- * Verifies that each Label DefDef has only a single address to jump back and
- * reorders them such that they are not nested and this address is a
- * fall-through address for the JVM.
- *
- * ```scala
- * <label> def foo(i: Int) = {
- *   <label> def bar = 0
- *   <label> def dough(i: Int) = if (i == 0) bar else foo(i-1)
- *   dough(i)
- * }
- *
- * foo(100)
- * ```
- *
- * will get rewritten to:
- *
- * ```scala
- * <label> def foo(i: Int) = dough(i)
- * <label> def dough(i: Int) = if (i == 0) bar else foo(i-1)
- * <label> def bar = 2
- * foo(100)
- * ```
- *
- * Proposed way to generate this pattern in backend is:
- *
- * ```scala
- * foo(100)
- * <jump foo>
- * <label> def foo(i: Int) = dough(i)
- * // <jump a>                           // unreachable
- * <label> def dough(i: Int) = if (i == 0) bar else foo(i-1)
- * // <jump a>                           // unreachable
- * <label> def bar = 2
- * // <jump a>                           // unreachable
- * <asm point a>
- * ```
- *
- * Unreachable jumps will be eliminated by local dead code analysis.
- * After JVM is smart enough to remove next-line jumps
- *
- * Note that Ychecking this phase requires softening scoping rules
- * as it intentionally allowed to break scoping rules inside methods for labels.
- * This is modified by setting `labelsReordered` flag in Phases.
- *
- * @author Dmitry Petrashko
- */
-class LabelDefs extends MiniPhase {
-  import tpd._
-
-  def phaseName: String = "labelDef"
-
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = {
-    if (tree.symbol is Label) tree
-    else {
-      val labelDefs = collectLabelDefs(tree.rhs)
-
-      def putLabelDefsNearCallees = new TreeMap() {
-        override def transform(tree: Tree)(implicit ctx: Context): Tree = {
-          tree match {
-            case t: Apply if labelDefs.contains(t.symbol) =>
-              val labelDef = labelDefs(t.symbol)
-              labelDefs -= t.symbol
-              val labelDef2 = cpy.DefDef(labelDef)(rhs = transform(labelDef.rhs))
-              Block(labelDef2:: Nil, t)
-            case t: DefDef =>
-              assert(t.symbol is Label)
-              EmptyTree
-            case t: If =>
-              // Trees generated by pattern matcher usually looks like the
-              // following:
-              //
-              //      ...
-              //               }
-              //              else case58(x704)
-              //           }
-              //          else case58(x704)
-              //       }
-              //      else case58(x704)
-              //
-              // First transform on the else branch will make labeldef
-              // inserted on a shallow node.
-              val elsep2 = transform(t.elsep)
-              val thenp2 = transform(t.thenp)
-              cpy.If(tree)(transform(t.cond), thenp2, elsep2)
-            case _ =>
-              if (!labelDefs.isEmpty) super.transform(tree) else tree
-          }
-        }
-      }
-
-      if (labelDefs.isEmpty) tree
-      else cpy.DefDef(tree)(rhs = putLabelDefsNearCallees.transform(tree.rhs))
-    }
-  }
-
-  private def collectLabelDefs(tree: Tree)(implicit ctx: Context): MutableSymbolMap[DefDef] = {
-    // labelSymbol -> Defining tree
-    val labelDefs = newMutableSymbolMap[DefDef]
-    new TreeTraverser {
-      override def traverse(tree: Tree)(implicit ctx: Context): Unit = tree match {
-        case t: DefDef =>
-          assert(t.symbol is Label)
-          labelDefs(t.symbol) = t
-          traverseChildren(t)
-        case _ => traverseChildren(tree)
-      }
-    }.traverse(tree)
-    labelDefs
-  }
-}
diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index 60a05d2d26c9..ec2a870e8c87 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -6,7 +6,7 @@ import Contexts._
 import typer.{FrontEnd, RefChecks}
 import Phases.Phase
 import transform._
-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
@@ -108,8 +108,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 */
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index d27497d27f66..71ea819f38a9 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -319,16 +319,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Block(cdef :: Nil, New(cls.typeRef, Nil))
   }
 
-  // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
-  def WhileDo(owner: Symbol, cond: Tree, body: List[Tree])(implicit ctx: Context): Tree = {
-    val sym = ctx.newSymbol(owner, nme.WHILE_PREFIX, Flags.Label | Flags.Synthetic,
-      MethodType(Nil, defn.UnitType), coord = cond.pos)
-
-    val call = Apply(ref(sym), Nil)
-    val rhs = If(cond, Block(body, call), unitLiteral)
-    Block(List(DefDef(sym, rhs)), call)
-  }
-
   def Import(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
     ta.assignType(untpd.Import(expr, selectors), ctx.newImportSymbol(ctx.owner, expr))
 
diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala
index f9736296524b..45aeeef52ec1 100644
--- a/compiler/src/dotty/tools/dotc/core/Flags.scala
+++ b/compiler/src/dotty/tools/dotc/core/Flags.scala
@@ -291,7 +291,7 @@ object Flags {
   final val Covariant: FlagSet = typeFlag(20, "<covariant>")
   final val OuterAccessor: FlagSet = termFlag(20, "<outer accessor>")
 
-  /** A contravariant type variable / a label method */
+  /** A contravariant type variable / the label of a labeled block */
   final val ContravariantOrLabel: FlagSet = commonFlag(21, "")
   final val Contravariant: FlagSet = typeFlag(21, "<contravariant>")
   final val Label: FlagSet = termFlag(21, "<label>")
@@ -581,9 +581,6 @@ object Flags {
   /** A lazy or deferred value */
   final val LazyOrDeferred: FlagSet = Lazy | Deferred
 
-  /** An accessor or label */
-  final val AccessorOrLabel: FlagSet = Accessor | Label
-
   /** An accessor or a synthetic symbol */
   final val AccessorOrSynthetic: FlagSet = Accessor | Synthetic
 
diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala
index cb9be7b30b74..fef04082ca57 100644
--- a/compiler/src/dotty/tools/dotc/core/Phases.scala
+++ b/compiler/src/dotty/tools/dotc/core/Phases.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 DenotTransformers._
 import Denotations._
 import Decorators._
@@ -329,7 +329,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
@@ -347,7 +346,6 @@ object Phases {
     final def erasedTypes: Boolean = myErasedTypes   // Phase is after erasure
     final def flatClasses: Boolean = myFlatClasses   // Phase is after flatten
     final def refChecked: Boolean = myRefChecked     // Phase is after RefChecks
-    final def labelsReordered: Boolean = myLabelsReordered // Phase is after LabelDefs, labels are flattened and owner chains don't mirror this
 
     final def sameMembersStartId: Int = mySameMembersStartId
       // id of first phase where all symbols are guaranteed to have the same members as in this phase
@@ -363,7 +361,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
     }
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index 5b96b5b41c2d..70fa2593c486 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -596,12 +596,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): Boolean =
-      this.is(Method, butNot = AccessorOrLabel) &&
+      this.is(Method, butNot = Accessor) &&
         !isAnonymousFunction &&
         !isCompanionMethod
 
@@ -765,12 +764,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
 
@@ -880,7 +878,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): Symbol = owner.skipWeakOwner
 
     /** The class containing this denotation.
@@ -925,7 +923,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
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
index 27b19c084913..65b57d7c99fa 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -181,7 +181,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))
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
index 741176aad85f..09f02b2ff6b9 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
@@ -192,7 +192,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 “+”
@@ -234,7 +233,7 @@ Standard Section: "Comments" Comment*
 object TastyFormat {
 
   final val header: Array[Int] = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion: Int = 12
+  val MajorVersion: Int = 13
   val MinorVersion: Int = 0
 
   /** Tags used to serialize names */
@@ -296,17 +295,16 @@ object TastyFormat {
   final val SYNTHETIC = 22
   final val ARTIFACT = 23
   final val MUTABLE = 24
-  final val LABEL = 25
-  final val FIELDaccessor = 26
-  final val CASEaccessor = 27
-  final val COVARIANT = 28
-  final val CONTRAVARIANT = 29
-  final val SCALA2X = 30
-  final val DEFAULTparameterized = 31
-  final val STABLE = 32
-  final val MACRO = 33
-  final val ERASED = 34
-  final val PARAMsetter = 35
+  final val FIELDaccessor = 25
+  final val CASEaccessor = 26
+  final val COVARIANT = 27
+  final val CONTRAVARIANT = 28
+  final val SCALA2X = 29
+  final val DEFAULTparameterized = 30
+  final val STABLE = 31
+  final val MACRO = 32
+  final val ERASED = 33
+  final val PARAMsetter = 34
 
   // Cat. 2:    tag Nat
 
@@ -466,7 +464,6 @@ object TastyFormat {
        | SYNTHETIC
        | ARTIFACT
        | MUTABLE
-       | LABEL
        | FIELDaccessor
        | CASEaccessor
        | COVARIANT
@@ -523,7 +520,6 @@ object TastyFormat {
     case SYNTHETIC => "SYNTHETIC"
     case ARTIFACT => "ARTIFACT"
     case MUTABLE => "MUTABLE"
-    case LABEL => "LABEL"
     case FIELDaccessor => "FIELDaccessor"
     case CASEaccessor => "CASEaccessor"
     case COVARIANT => "COVARIANT"
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 5a4cbc312076..217c88012f2d 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -627,7 +627,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)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index fcabd7184550..019c3649752c 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -613,7 +613,6 @@ class TreeUnpickler(reader: TastyReader,
           case SYNTHETIC => addFlag(Synthetic)
           case ARTIFACT => addFlag(Artifact)
           case MUTABLE => addFlag(Mutable)
-          case LABEL => addFlag(Label)
           case FIELDaccessor => addFlag(Accessor)
           case CASEaccessor => addFlag(CaseAccessor)
           case COVARIANT => addFlag(Covariant)
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
index 943f466d2584..40a968705998 100644
--- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -1034,6 +1034,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         TypeDef(symbol.asType)
 
       case LABELtree =>
+        ???
         setSymName()
         val rhs = readTreeRef()
         val params = until(end, () => readIdentRef())
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index c869259019a1..afd2b15f794e 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -67,7 +67,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   override protected def recursionLimitExceeded(): Unit = {}
 
-  protected val PrintableFlags: FlagSet = (SourceModifierFlags | Label | Module | Local).toCommonFlags
+  protected val PrintableFlags: FlagSet = (SourceModifierFlags | Module | Local).toCommonFlags
 
   override def nameString(name: Name): String =
     if (ctx.settings.YdebugNames.value) name.debugString else name.toString
diff --git a/compiler/src/dotty/tools/dotc/quoted/RefreshNames.scala b/compiler/src/dotty/tools/dotc/quoted/RefreshNames.scala
index f43fc44c63ec..4b00eb00079e 100644
--- a/compiler/src/dotty/tools/dotc/quoted/RefreshNames.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/RefreshNames.scala
@@ -26,7 +26,7 @@ class RefreshNames extends MiniPhase with SymTransformer {
   }
 
   def transformSym(ref: SymDenotation)(implicit ctx: Context): SymDenotation = {
-    if (ref.is(Package) || ref.isClass || ref.owner != ctx.owner || ref.is(Label) || ref.is(Param)) ref
+    if (ref.is(Package) || ref.isClass || ref.owner != ctx.owner || ref.is(Param)) ref
     else {
       val newName = UniqueName.fresh(ref.symbol.name.toTermName)
       newName.info match {
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/FlagSet.scala b/compiler/src/dotty/tools/dotc/tastyreflect/FlagSet.scala
index 84d52471a9c4..54918c3ce27e 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/FlagSet.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/FlagSet.scala
@@ -23,7 +23,6 @@ class FlagSet(flags: Flags.FlagSet) extends scala.tasty.reflect.FlagSet {
   def isSynthetic: Boolean = flags.is(Synthetic)
   def isArtifact: Boolean = flags.is(Artifact)
   def isMutable: Boolean = flags.is(Mutable)
-  def isLabel: Boolean = flags.is(Label)
   def isFieldAccessor: Boolean = flags.is(Accessor)
   def isCaseAcessor: Boolean = flags.is(CaseAccessor)
   def isCovariant: Boolean = flags.is(Covariant)
@@ -54,7 +53,6 @@ class FlagSet(flags: Flags.FlagSet) extends scala.tasty.reflect.FlagSet {
     if (isSynthetic) flags += "synthetic"
     if (isArtifact) flags += "artifact"
     if (isMutable) flags += "mutable"
-    if (isLabel) flags += "label"
     if (isFieldAccessor) flags += "accessor"
     if (isCaseAcessor) flags += "caseAccessor"
     if (isCovariant) flags += "covariant"
diff --git a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
index a0093c8635ce..1c90a14f5cf6 100644
--- a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
@@ -201,10 +201,7 @@ object LambdaLift {
         tree match {
           case tree: Ident =>
             if (isLocal(sym)) {
-              if (sym is Label)
-                assert(enclosure == sym.enclosure,
-                  i"attempt to refer to label $sym from nested $enclosure")
-              else if (sym is Method) markCalled(sym, enclosure)
+              if (sym is Method) markCalled(sym, enclosure)
               else if (sym.isTerm) markFree(sym, enclosure)
             }
             def captureImplicitThis(x: Type): Unit = {
@@ -220,7 +217,7 @@ object LambdaLift {
           case tree: This =>
             narrowTo(tree.symbol.asClass)
           case tree: DefDef =>
-            if (sym.owner.isTerm && !sym.is(Label))
+            if (sym.owner.isTerm)
               liftedOwner(sym) = sym.enclosingPackageClass
                 // this will make methods in supercall constructors of top-level classes owned
                 // by the enclosing package, which means they will be static.
@@ -288,7 +285,7 @@ object LambdaLift {
       } while (changedLiftedOwner)
 
     private def newName(sym: Symbol)(implicit ctx: Context): Name =
-      if (sym.isAnonymousFunction && sym.owner.is(Method, butNot = Label))
+      if (sym.isAnonymousFunction && sym.owner.is(Method))
         sym.name.replace {
           case name: SimpleName => ExpandPrefixName(sym.owner.name.asTermName, name)
         }.freshened
diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
index 4f1df2e825d3..87d35963dd40 100644
--- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -370,8 +370,8 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     val cases = Match(stateMask.appliedTo(ref(flagSymbol), Literal(Constant(ord))),
       List(compute, waitFirst, waitSecond, computed, default)) //todo: annotate with @switch
 
-    val whileBody = List(ref(flagSymbol).becomes(getFlag.appliedTo(thiz, offset)), cases)
-    val cycle = WhileDo(methodSymbol, whileCond, whileBody)
+    val whileBody = Block(ref(flagSymbol).becomes(getFlag.appliedTo(thiz, offset)) :: Nil, cases)
+    val cycle = WhileDo(whileCond, whileBody)
     val setNullables = nullOut(nullables)
     DefDef(methodSymbol, Block(resultDef :: retryDef :: flagDef :: cycle :: setNullables, ref(resultSymbol)))
   }
diff --git a/compiler/src/dotty/tools/dotc/transform/LiftTry.scala b/compiler/src/dotty/tools/dotc/transform/LiftTry.scala
index 751db8fc593c..5faf20ce7d00 100644
--- a/compiler/src/dotty/tools/dotc/transform/LiftTry.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LiftTry.scala
@@ -43,8 +43,7 @@ class LiftTry extends MiniPhase with IdentityDenotTransformer { thisPhase =>
     if (needLift == p) ctx else ctx.fresh.updateStore(NeedLift, p)
 
   override def prepareForApply(tree: Apply)(implicit ctx: Context): Context =
-    if (tree.fun.symbol.is(Label)) ctx
-    else liftingCtx(true)
+    liftingCtx(true)
 
   override def prepareForValDef(tree: ValDef)(implicit ctx: Context): Context =
     if (!tree.symbol.exists  ||
diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 1ab82d6579ee..c2a69e409a03 100644
--- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -227,8 +227,8 @@ object PatternMatcher {
          * val x3: Int = x1._2
          * if (x2 == 1) {
          *   if (x3 == 2) someCode
-         *   else label$1()
-         * } else label$1()
+         *   else ()
+         * } else ()
          * ```
          */
         def matchArgsSelectorsPlan(selectors: List[Tree], syms: List[Symbol]): Plan =
@@ -799,15 +799,15 @@ object PatternMatcher {
            *  val x2: Int = ...
            *  if (x1 == y1) {
            *    if (x2 == y2) someCode
-           *    else label$1()
-           *  } else label$1()
+           *    else ()
+           *  } else ()
            *  ```
            *  is emitted as
            *  ```
            *  val x1: Int = ...
            *  val x2: Int = ...
            *  if (x1 == y1 && x2 == y2) someCode
-           *  else label$1()
+           *  else ()
            *  ```
            */
           def emitWithMashedConditions(plans: List[TestPlan]): Tree = {
diff --git a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
index 540b372c3197..05da7650d68e 100644
--- a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -70,7 +70,7 @@ class SymUtils(val self: Symbol) extends AnyVal {
 
   /** The closest enclosing method or class of this symbol */
   @tailrec final def enclosingMethodOrClass(implicit ctx: Context): Symbol =
-    if (self.is(Method, butNot = Label) || self.isClass) self
+    if (self.is(Method) || self.isClass) self
     else if (self.exists) self.owner.enclosingMethodOrClass
     else NoSymbol
 
diff --git a/compiler/src/dotty/tools/dotc/transform/TailRec.scala b/compiler/src/dotty/tools/dotc/transform/TailRec.scala
index f0a5dbaa1fc7..37411bb06bae 100644
--- a/compiler/src/dotty/tools/dotc/transform/TailRec.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TailRec.scala
@@ -114,7 +114,7 @@ class TailRec extends MiniPhase {
     val sym = tree.symbol
     tree match {
       case dd@DefDef(name, Nil, vparams :: Nil, tpt, _)
-        if (sym.isEffectivelyFinal) && !((sym is Flags.Accessor) || (dd.rhs eq EmptyTree) || (sym is Flags.Label)) =>
+        if (sym.isEffectivelyFinal) && !((sym is Flags.Accessor) || (dd.rhs eq EmptyTree)) =>
         val mandatory = sym.hasAnnotation(defn.TailrecAnnot)
         cpy.DefDef(dd)(rhs = {
           val defIsTopLevel = sym.owner.isClass
@@ -393,10 +393,7 @@ class TailRec extends MiniPhase {
           assert(false, "We should never have gotten inside a pattern")
           tree
 
-        case t @ DefDef(_, _, _, _, _) =>
-          t // todo: could improve to handle DefDef's with a label flag calls to which are in tail position
-
-        case ValDef(_, _, _) | EmptyTree | Super(_, _) | This(_) |
+        case ValDef(_, _, _) | DefDef(_, _, _, _, _) | EmptyTree | Super(_, _) | This(_) |
              Literal(_) | TypeTree() | TypeDef(_, _) =>
           tree
 
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 72fb88bb249f..39f36bc4007f 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -179,10 +179,7 @@ class TreeChecker extends Phase with SymTransformer {
     }
 
     def assertDefined(tree: untpd.Tree)(implicit ctx: Context): Unit =
-      if (
-        tree.symbol.maybeOwner.isTerm &&
-        !(tree.symbol.is(Label | Method) && !tree.symbol.owner.isClass && ctx.phase.labelsReordered) // labeldefs breaks scoping
-      )
+      if (tree.symbol.maybeOwner.isTerm)
         assert(nowDefinedSyms contains tree.symbol, i"undefined symbol ${tree.symbol} at line " + tree.pos.line)
 
     /** assert Java classes are not used as objects */
@@ -356,8 +353,7 @@ class TreeChecker extends Phase with SymTransformer {
     private def checkOwner(tree: untpd.Tree)(implicit ctx: Context): Unit = {
       def ownerMatches(symOwner: Symbol, ctxOwner: Symbol): Boolean =
         symOwner == ctxOwner ||
-        ctxOwner.isWeakOwner && ownerMatches(symOwner, ctxOwner.owner) ||
-        ctx.phase.labelsReordered && symOwner.isWeakOwner && ownerMatches(symOwner.owner, ctxOwner)
+        ctxOwner.isWeakOwner && ownerMatches(symOwner, ctxOwner.owner)
       assert(ownerMatches(tree.symbol.owner, ctx.owner),
         i"bad owner; ${tree.symbol} has owner ${tree.symbol.owner}, expected was ${ctx.owner}\n" +
         i"owner chain = ${tree.symbol.ownersIterator.toList}%, %, ctxOwners = ${ctx.outersIterator.map(_.owner).toList}%, %")
@@ -445,10 +441,8 @@ class TreeChecker extends Phase with SymTransformer {
       val tree1 = super.typedReturn(tree)
       val from = tree1.from
       val fromSym = from.symbol
-      if (fromSym.is(Label)) {
-        assert(!fromSym.is(Method), i"return from a label-def $fromSym at $tree")
+      if (fromSym.is(Label))
         assertDefined(from)
-      }
       tree1
     }
 
diff --git a/docs/docs/internals/overall-structure.md b/docs/docs/internals/overall-structure.md
index 31ada3c70b08..2115bfeb52b6 100644
--- a/docs/docs/internals/overall-structure.md
+++ b/docs/docs/internals/overall-structure.md
@@ -91,66 +91,92 @@ Seen from a temporal perspective, the `dotc` compiler consists of a list of
 phases. The current list of phases is specified in class [Compiler] as follows:
 
 ```scala
-    def phases: List[List[Phase]] = List(
-      List(new FrontEnd),           // Compiler frontend: scanner, parser, namer, typer
-      List(new sbt.ExtractDependencies), // Sends information on classes' dependencies to sbt via callbacks
-      List(new PostTyper),          // Additional checks and cleanups after type checking
-      List(new sbt.ExtractAPI),     // Sends a representation of the API of classes to sbt via callbacks
-      List(new Pickler),            // Generate TASTY info
-      List(new FirstTransform,      // Some transformations to put trees into a canonical form
-           new CheckReentrant),     // Internal use only: Check that compiled program has no data races involving global vars
-      List(new RefChecks,           // Various checks mostly related to abstract members and overriding
-           new CheckStatic,         // Check restrictions that apply to @static members
-           new ElimRepeated,        // Rewrite vararg parameters and arguments
-           new NormalizeFlags,      // Rewrite some definition flags
-           new ExtensionMethods,    // Expand methods of value classes with extension methods
-           new ExpandSAMs,          // Expand single abstract method closures to anonymous classes
-           new TailRec,             // Rewrite tail recursion to loops
-           new LiftTry,             // Put try expressions that might execute on non-empty stacks into their own methods
-           new ClassOf),            // Expand `Predef.classOf` calls.
-      List(new TryCatchPatterns,    // Compile cases in try/catch
-           new PatternMatcher,      // Compile pattern matches
-           new ExplicitOuter,       // Add accessors to outer classes from nested ones.
-           new ExplicitSelf,        // Make references to non-trivial self types explicit as casts
-           new ShortcutImplicits,   // Allow implicit functions without creating closures
-           new CrossCastAnd,        // Normalize selections involving intersection types.
-           new Splitter),           // Expand selections involving union types into conditionals
-      List(new VCInlineMethods,     // Inlines calls to value class methods
-           new IsInstanceOfEvaluator, // Issues warnings when unreachable statements are present in match/if expressions
-           new SeqLiterals,         // Express vararg arguments as arrays
-           new InterceptedMethods,  // Special handling of `==`, `|=`, `getClass` methods
-           new Getters,             // Replace non-private vals and vars with getter defs (fields are added later)
-           new ElimByName,          // Expand by-name parameters and arguments
-           new AugmentScala2Traits, // Expand traits defined in Scala 2.11 to simulate old-style rewritings
-           new ResolveSuper,        // Implement super accessors and add forwarders to trait methods
-           new ArrayConstructors),  // Intercept creation of (non-generic) arrays and intrinsify.
-      List(new Erasure),            // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
-      List(new ElimErasedValueType, // Expand erased value types to their underlying implementation types
-           new VCElideAllocations,  // Peep-hole optimization to eliminate unnecessary value class allocations
-           new Mixin,               // Expand trait fields and trait initializers
-           new LazyVals,            // Expand lazy vals
-           new Memoize,             // Add private fields to getters and setters
-           new LinkScala2ImplClasses, // Forward calls to the implementation classes of traits defined by Scala 2.11
-           new NonLocalReturns,     // Expand non-local returns
-           new CapturedVars,        // Represent vars captured by closures as heap objects
-           new Constructors,        // Collect initialization code in primary constructors
-                                       // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
-           new FunctionalInterfaces,// Rewrites closures to implement @specialized types of Functions.
-           new GetClass),           // Rewrites getClass calls on primitive types.
-      List(new LambdaLift,          // Lifts out nested functions to class scope, storing free variables in environments
-                                       // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
-           new ElimStaticThis,      // Replace `this` references to static objects by global identifiers
-           new Flatten,             // Lift all inner classes to package scope
-           new RestoreScopes),      // Repair scopes rendered invalid by moving definitions in prior phases of the group
-      List(new ExpandPrivate,       // Widen private definitions accessed from nested classes
-           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 DropInlined,         // Drop Inlined nodes, since backend has no use for them
-           new MoveStatics,         // Move static methods to companion classes
-           new LabelDefs),          // Converts calls to labels to jumps
-      List(new GenBCode)            // Generate JVM bytecode
-    )
+  def phases: List[List[Phase]] =
+    frontendPhases ::: picklerPhases ::: transformPhases ::: backendPhases
+
+  /** Phases dealing with the frontend up to trees ready for TASTY pickling */
+  protected def frontendPhases: List[List[Phase]] =
+    List(new FrontEnd) ::           // Compiler frontend: scanner, parser, namer, typer
+    List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
+    List(new PostTyper) ::          // Additional checks and cleanups after type checking
+    List(new sbt.ExtractAPI) ::     // Sends a representation of the API of classes to sbt via callbacks
+    Nil
+
+  /** Phases dealing with TASTY tree pickling and unpickling */
+  protected def picklerPhases: List[List[Phase]] =
+    List(new Pickler) ::            // Generate TASTY info
+    List(new ReifyQuotes) ::        // Turn quoted trees into explicit run-time data structures
+    Nil
+
+  /** Phases dealing with the transformation from pickled trees to backend trees */
+  protected def transformPhases: List[List[Phase]] =
+    List(new FirstTransform,         // Some transformations to put trees into a canonical form
+         new CheckReentrant,         // Internal use only: Check that compiled program has no data races involving global vars
+         new ElimPackagePrefixes,    // Eliminate references to package prefixes in Select nodes
+         new CookComments) ::        // Cook the comments: expand variables, doc, etc.
+    List(new CheckStatic,            // Check restrictions that apply to @static members
+         new ElimRepeated,           // Rewrite vararg parameters and arguments
+         new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
+         new ProtectedAccessors,     // Add accessors for protected members
+         new ExtensionMethods,       // Expand methods of value classes with extension methods
+         new ShortcutImplicits,      // Allow implicit functions without creating closures
+         new ByNameClosures,         // Expand arguments to by-name parameters to closures
+         new LiftTry,                // Put try expressions that might execute on non-empty stacks into their own methods
+         new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope
+         new ClassOf,                // Expand `Predef.classOf` calls.
+         new RefChecks) ::           // Various checks mostly related to abstract members and overriding
+    List(new TryCatchPatterns,       // Compile cases in try/catch
+         new PatternMatcher,         // Compile pattern matches
+         new ExplicitOuter,          // Add accessors to outer classes from nested ones.
+         new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
+         new StringInterpolatorOpt,  // Optimizes raw and s string interpolators by rewriting them to string concatentations
+         new CrossCastAnd,           // Normalize selections involving intersection types.
+         new Splitter) ::            // Expand selections involving union types into conditionals
+    List(new PruneErasedDefs,        // Drop erased definitions from scopes and simplify erased expressions
+         new VCInlineMethods,        // Inlines calls to value class methods
+         new SeqLiterals,            // Express vararg arguments as arrays
+         new InterceptedMethods,     // Special handling of `==`, `|=`, `getClass` methods
+         new Getters,                // Replace non-private vals and vars with getter defs (fields are added later)
+         new ElimByName,             // Expand by-name parameter references
+         new CollectNullableFields,  // Collect fields that can be nulled out after use in lazy initialization
+         new ElimOuterSelect,        // Expand outer selections
+         new AugmentScala2Traits,    // Expand traits defined in Scala 2.x to simulate old-style rewritings
+         new ResolveSuper,           // Implement super accessors and add forwarders to trait methods
+         new PrimitiveForwarders,    // Add forwarders to trait methods that have a mismatch between generic and primitives
+         new FunctionXXLForwarders,  // Add forwarders for FunctionXXL apply method
+         new ArrayConstructors) ::   // Intercept creation of (non-generic) arrays and intrinsify.
+    List(new Erasure) ::             // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
+    List(new ElimErasedValueType,    // Expand erased value types to their underlying implmementation types
+         new VCElideAllocations,     // Peep-hole optimization to eliminate unnecessary value class allocations
+         new TailRec,                // Rewrite tail recursion to loops
+         new Mixin,                  // Expand trait fields and trait initializers
+         new LazyVals,               // Expand lazy vals
+         new Memoize,                // Add private fields to getters and setters
+         new NonLocalReturns,        // Expand non-local returns
+         new CapturedVars) ::        // Represent vars captured by closures as heap objects
+    List(new Constructors,           // Collect initialization code in primary constructors
+                                        // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
+         new FunctionalInterfaces,   // Rewrites closures to implement @specialized types of Functions.
+         new GetClass) ::            // Rewrites getClass calls on primitive types.
+    List(new LinkScala2Impls,        // Redirect calls to trait methods defined by Scala 2.x, so that they now go to their implementations
+         new LambdaLift,             // Lifts out nested functions to class scope, storing free variables in environments
+                                        // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
+         new ElimStaticThis) ::      // Replace `this` references to static objects by global identifiers
+    List(new Flatten,                // Lift all inner classes to package scope
+         new RenameLifted,           // Renames lifted classes to local numbering scheme
+         new TransformWildcards,     // Replace wildcards with default values
+         new MoveStatics,            // Move static methods from companion to the class itself
+         new ExpandPrivate,          // Widen private definitions accessed from nested classes
+         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
+    Nil
+
+  /** Generate the output of the compilation */
+  protected def backendPhases: List[List[Phase]] =
+    List(new GenBCode) ::            // Generate JVM bytecode
+    Nil
 ```
 
 Note that phases are grouped, so the `phases` method is of type
@@ -183,11 +209,11 @@ Phases fall into four categories:
   instead of Scala's.
 
 * Low-level transformations: All phases from `ElimErasedValueType` to
-  `LabelDefs`. These further transform trees until they are essentially a
+  `CollectSuperCalls`. These further transform trees until they are essentially a
   structured version of Java bytecode.
 
 * Code generators: These map the transformed trees to Java classfiles or
-  Javascript files.
+  .sjsir files.
 
 [dotty.tools]: https://github.com/lampepfl/dotty/tree/master/compiler/src/dotty/tools
 [dotc]: https://github.com/lampepfl/dotty/tree/master/compiler/src/dotty/tools/dotc
diff --git a/library/src/scala/tasty/reflect/FlagSet.scala b/library/src/scala/tasty/reflect/FlagSet.scala
index 6421c48e90c1..860c51bdb290 100644
--- a/library/src/scala/tasty/reflect/FlagSet.scala
+++ b/library/src/scala/tasty/reflect/FlagSet.scala
@@ -19,7 +19,6 @@ trait FlagSet {
   def isSynthetic: Boolean             // generated by Scala compiler
   def isArtifact: Boolean              // to be tagged Java Synthetic
   def isMutable: Boolean               // when used on a ValDef: a var
-  def isLabel: Boolean                 // method generated as a label
   def isFieldAccessor: Boolean         // a getter or setter
   def isCaseAcessor: Boolean           // getter for class parameter
   def isCovariant: Boolean             // type parameter marked “+”
diff --git a/project/Build.scala b/project/Build.scala
index f4091d6f625f..670e1983a41b 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -1261,7 +1261,7 @@ object Build {
   //     mainClass in Compile := Some("hello.world"),
 
   //     // While developing the Scala.js back-end, it is very useful to see the trees dotc gives us
-  //     scalacOptions += "-Xprint:labelDef",
+  //     scalacOptions += "-Xprint:collectSuperCalls",
 
   //     /* Debug-friendly Scala.js optimizer options.
   //      * In particular, typecheck the Scala.js IR found on the classpath.
diff --git a/scala-backend b/scala-backend
index 18b3f30e8c30..34af0ce0721a 160000
--- a/scala-backend
+++ b/scala-backend
@@ -1 +1 @@
-Subproject commit 18b3f30e8c302ddd0e404f1b3dacf877eb6257c5
+Subproject commit 34af0ce0721a2b7e19bab68c464d756ad7dc778f