From 0e98da6ce59e278a1682ab8d44b15cb7902863ee Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Wed, 18 Oct 2017 12:10:53 +0200 Subject: [PATCH 01/20] Always run ensureOuterAccessors at phase explicitOuter + 1 --- .../dotty/tools/dotc/transform/ExplicitOuter.scala | 12 ++++-------- .../dotty/tools/dotc/transform/PatternMatcher.scala | 2 +- 2 files changed, 5 insertions(+), 9 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala index f17bec6f13fb..54e474888654 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala @@ -132,15 +132,11 @@ object ExplicitOuter { import ast.tpd._ /** Ensure that class `cls` has outer accessors */ - def ensureOuterAccessors(cls: ClassSymbol)(implicit ctx: Context): Unit = { - //todo: implementing #165 would simplify this logic - val prevPhase = ctx.phase.prev - assert(prevPhase.id <= ctx.explicitOuterPhase.id, "can add $outer symbols only before ExplicitOuter") - assert(prevPhase.isInstanceOf[DenotTransformer], "adding outerAccessors requires being DenotTransformer") - if (!hasOuter(cls)) { - newOuterAccessors(cls).foreach(_.enteredAfter(prevPhase.asInstanceOf[DenotTransformer])) + def ensureOuterAccessors(cls: ClassSymbol)(implicit ctx: Context): Unit = + ctx.atPhase(ctx.explicitOuterPhase.next) { implicit ctx => + if (!hasOuter(cls)) + newOuterAccessors(cls).foreach(_.enteredAfter(ctx.explicitOuterPhase.asInstanceOf[DenotTransformer])) } - } /** The outer accessor and potentially outer param accessor needed for class `cls` */ private def newOuterAccessors(cls: ClassSymbol)(implicit ctx: Context) = diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala index 0d3ec5ac55d5..6e8f3141d39b 100644 --- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala +++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala @@ -768,7 +768,7 @@ object PatternMatcher { def outerTest: Tree = trans.transformFollowingDeep { val expectedOuter = singleton(expectedTp.normalizedPrefix) val expectedClass = expectedTp.dealias.classSymbol.asClass - ExplicitOuter.ensureOuterAccessors(expectedClass)(ctx.withPhase(ctx.explicitOuterPhase.next)) + ExplicitOuter.ensureOuterAccessors(expectedClass) scrutinee.ensureConforms(expectedTp) .outerSelect(1, expectedOuter.tpe.widen) .select(defn.Object_eq) From f4aa1b67fb63b106f93ad041e933a881d1131c62 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 19 Oct 2017 09:43:40 +0200 Subject: [PATCH 02/20] Allow phases to choose to run at group end --- compiler/src/dotty/tools/dotc/ast/tpd.scala | 37 ++++++++++--------- .../tools/dotc/transform/TreeTransform.scala | 16 ++++---- 2 files changed, 28 insertions(+), 25 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala index 8e23819aa77d..df03eda317cc 100644 --- a/compiler/src/dotty/tools/dotc/ast/tpd.scala +++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala @@ -656,26 +656,27 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { /** After phase `trans`, set the owner of every definition in this tree that was formerly * owner by `from` to `to`. */ - def changeOwnerAfter(from: Symbol, to: Symbol, trans: DenotTransformer)(implicit ctx: Context): ThisTree = { - assert(ctx.phase == trans.next) - val traverser = new TreeTraverser { - def traverse(tree: Tree)(implicit ctx: Context) = tree match { - case tree: DefTree => - val sym = tree.symbol - val prevDenot = sym.denot(ctx.withPhase(trans)) - if (prevDenot.effectiveOwner == from.skipWeakOwner) { - val d = sym.copySymDenotation(owner = to) - d.installAfter(trans) - d.transformAfter(trans, d => if (d.owner eq from) d.copySymDenotation(owner = to) else d) - } - if (sym.isWeakOwner) traverseChildren(tree) - case _ => - traverseChildren(tree) + def changeOwnerAfter(from: Symbol, to: Symbol, trans: DenotTransformer)(implicit ctx: Context): ThisTree = + if (ctx.phase == trans.next) { + val traverser = new TreeTraverser { + def traverse(tree: Tree)(implicit ctx: Context) = tree match { + case tree: DefTree => + val sym = tree.symbol + val prevDenot = sym.denot(ctx.withPhase(trans)) + if (prevDenot.effectiveOwner == from.skipWeakOwner) { + val d = sym.copySymDenotation(owner = to) + d.installAfter(trans) + d.transformAfter(trans, d => if (d.owner eq from) d.copySymDenotation(owner = to) else d) + } + if (sym.isWeakOwner) traverseChildren(tree) + case _ => + traverseChildren(tree) + } } + traverser.traverse(tree) + tree } - traverser.traverse(tree) - tree - } + else changeOwnerAfter(from, to, trans)(ctx.withPhase(trans.next)) /** A select node with the given selector name and a computed type */ def select(name: Name)(implicit ctx: Context): Select = diff --git a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala index b2a1ccd699d5..420ac3cca9ea 100644 --- a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala +++ b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala @@ -62,7 +62,8 @@ object TreeTransforms { def phase: MiniPhase /** The phase at which the tree is transformed */ - final def treeTransformPhase: Phase = phase.next + def treeTransformPhase(implicit ctx: Context, info: TransformerInfo): Phase = + phase.next val cpy: TypedTreeCopier = cpyBetweenPhases @@ -140,10 +141,11 @@ object TreeTransforms { /** Transform single node using all transforms following the current one in this group */ def transformFollowing(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = info.group.transformSingle(tree, phase.idx + 1) - def atGroupEnd[T](action : Context => T)(implicit ctx: Context, info: TransformerInfo) = { - val last = info.transformers(info.transformers.length - 1) - action(ctx.withPhase(last.phase.next)) - } + def atGroupEnd[T](action : Context => T)(implicit ctx: Context, info: TransformerInfo) = + action(ctx.withPhase(groupEndPhase)) + + def groupEndPhase(implicit ctx: Context, info: TransformerInfo) = + info.transformers(info.transformers.length - 1).phase.next } /** A phase that defines a TreeTransform to be used in a group */ @@ -494,7 +496,7 @@ object TreeTransforms { var allDone = i < l while (i < l) { val oldTransform = result(i) - val newTransform = mutator(oldTransform, tree, ctx.withPhase(oldTransform.treeTransformPhase)) + val newTransform = mutator(oldTransform, tree, ctx.withPhase(oldTransform.treeTransformPhase(ctx, info))) allDone = allDone && (newTransform eq NoTransform) if (!(oldTransform eq newTransform)) { if (!transformersCopied) result = result.clone() @@ -1180,7 +1182,7 @@ object TreeTransforms { util.Stats.record("TreeTransform.transform") // if cur > 0 then some of the symbols can be created by already performed transformations // this means that their denotations could not exists in previous period - val pctx = ctx.withPhase(info.transformers(cur).treeTransformPhase) + val pctx = ctx.withPhase(info.transformers(cur).treeTransformPhase(ctx, info)) tree match { //split one big match into 2 smaller ones case tree: NameTree => transformNamed(tree, info, cur)(pctx) From 9ee439a787d00bc42c61c01c347dab999e69fb19 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 19 Oct 2017 09:44:32 +0200 Subject: [PATCH 03/20] Run all phases in last group at group end --- compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala | 3 +++ compiler/src/dotty/tools/backend/jvm/LabelDefs.scala | 3 +++ .../src/dotty/tools/dotc/transform/CollectEntryPoints.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/DropInlined.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala | 5 ++++- compiler/src/dotty/tools/dotc/transform/MoveStatics.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/RenameLifted.scala | 5 ++++- compiler/src/dotty/tools/dotc/transform/SelectStatic.scala | 3 +++ .../src/dotty/tools/dotc/transform/TransformWildcards.scala | 3 +++ 9 files changed, 29 insertions(+), 2 deletions(-) diff --git a/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala b/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala index 8285bfe4b5e9..d858e8f671b7 100644 --- a/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala +++ b/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala @@ -22,6 +22,9 @@ class CollectSuperCalls extends MiniPhaseTransform { def phaseName: String = "collectSuperCalls" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformSelect(tree: Select)(implicit ctx: Context, info: TransformerInfo): Tree = { tree.qualifier match { case sup: Super => diff --git a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala index eabe1d3b0c3b..60b2a3be0411 100644 --- a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala +++ b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala @@ -88,6 +88,9 @@ class LabelDefs extends MiniPhaseTransform { val beingAppended = new mutable.HashSet[Symbol]() var labelLevel = 0 + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { if (tree.symbol is Flags.Label) tree else { diff --git a/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala b/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala index 893e79ce0282..1463a167579e 100644 --- a/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala +++ b/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala @@ -24,6 +24,9 @@ import dotty.tools.dotc.config.JavaPlatform class CollectEntryPoints extends MiniPhaseTransform { + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + /** perform context-dependant initialization */ override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context) = { entryPoints = collection.immutable.TreeSet.empty[Symbol](new SymbolOrdering()) diff --git a/compiler/src/dotty/tools/dotc/transform/DropInlined.scala b/compiler/src/dotty/tools/dotc/transform/DropInlined.scala index 775663b5c261..83adb99b416e 100644 --- a/compiler/src/dotty/tools/dotc/transform/DropInlined.scala +++ b/compiler/src/dotty/tools/dotc/transform/DropInlined.scala @@ -10,6 +10,9 @@ class DropInlined extends MiniPhaseTransform { import ast.tpd._ override def phaseName = "dropInlined" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformInlined(tree: Inlined)(implicit ctx: Context, info: TransformerInfo): Tree = Inliner.dropInlined(tree) } diff --git a/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala b/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala index 5f89923159f0..6d4c9daa79cd 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala @@ -25,7 +25,7 @@ import dotty.tools.dotc.core.Phases.Phase /** Make private term members that are accessed from another class * non-private by resetting the Private flag and expanding their name. * - * Make private accessor in value class not-private. Ihis is necessary to unbox + * Make private accessor in value class not-private. This is necessary to unbox * the value class when accessing it from separate compilation units * * Also, make non-private any private parameter forwarders that forward to an inherited @@ -41,6 +41,9 @@ class ExpandPrivate extends MiniPhaseTransform with IdentityDenotTransformer { t override def phaseName: String = "expandPrivate" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + // This phase moves methods around (in infotransform) so it may need to make other methods public override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[MoveStatics]) diff --git a/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala b/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala index 0942c0b4af11..7077a5bc86ba 100644 --- a/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala +++ b/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala @@ -21,6 +21,9 @@ class MoveStatics extends MiniPhaseTransform with SymTransformer { thisTransform import tpd._ override def phaseName = "moveStatic" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation = { if (sym.hasAnnotation(defn.ScalaStaticAnnot) && sym.owner.is(Flags.Module) && sym.owner.companionClass.exists) { sym.owner.asClass.delete(sym.symbol) diff --git a/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala b/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala index fca24d71b8cf..a9b4fda27eab 100644 --- a/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala +++ b/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala @@ -9,7 +9,7 @@ import dotty.tools.dotc.core.Names._ import dotty.tools.dotc.core.Phases import dotty.tools.dotc.core.SymDenotations.SymDenotation import dotty.tools.dotc.core.Symbols._ -import dotty.tools.dotc.transform.TreeTransforms.MiniPhaseTransform +import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo} /** Renames lifted classes to local numbering scheme */ class RenameLifted extends MiniPhaseTransform with SymTransformer { thisTransformer => @@ -18,6 +18,9 @@ class RenameLifted extends MiniPhaseTransform with SymTransformer { thisTransfor override def runsAfterGroupsOf: Set[Class[_ <: Phases.Phase]] = Set(classOf[RestoreScopes]) + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + def transformSym(ref: SymDenotation)(implicit ctx: Context): SymDenotation = if (needsRefresh(ref.symbol)) ref.copySymDenotation(name = refreshedName(ref.symbol)) else ref diff --git a/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala b/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala index b90c6ed37620..f261fa3eda5b 100644 --- a/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala +++ b/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala @@ -20,6 +20,9 @@ class SelectStatic extends MiniPhaseTransform with IdentityDenotTransformer { th override def phaseName: String = "selectStatic" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformSelect(tree: tpd.Select)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { val sym = tree.symbol def isStaticMember = diff --git a/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala b/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala index 946722227af9..9aa487f1faf6 100644 --- a/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala +++ b/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala @@ -16,6 +16,9 @@ class TransformWildcards extends MiniPhaseTransform with IdentityDenotTransforme override def phaseName = "transformWildcards" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = { tree match { case vDef: ValDef => assert(!tpd.isWildcardArg(vDef.rhs)) From 50ff94834d274716da49151d05a8a77494729d3c Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 19 Oct 2017 10:18:11 +0200 Subject: [PATCH 04/20] Run all phases in first group at group end --- compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/FirstTransform.scala | 3 +++ 2 files changed, 6 insertions(+) diff --git a/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala b/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala index 92228b9a8463..2da9ca0b6a32 100644 --- a/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala +++ b/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala @@ -45,6 +45,9 @@ class CheckReentrant extends MiniPhaseTransform { thisTransformer => override def phaseName = "checkReentrant" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + private[this] var shared: Set[Symbol] = Set() private[this] var seen: Set[ClassSymbol] = Set() private[this] var indent: Int = 0 diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala index 35e2d8653d0e..0b068ca6f9e3 100644 --- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala +++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala @@ -40,6 +40,9 @@ class FirstTransform extends MiniPhaseTransform with InfoTransformer { thisTrans override def phaseName = "firstTransform" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + private[this] var addCompanionPhases: List[NeedsCompanions] = _ override def changesMembers = true // the phase adds companion objects From a5ed3bc917a526aaf61de0cab68018da1655c6cd Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 19 Oct 2017 10:52:59 +0200 Subject: [PATCH 05/20] Run most phases in second group at group end Only exception is RefChecks which produces errors when run at end of group. Probably because it clashes with ExtensionMethods. --- .../src/dotty/tools/dotc/transform/ByNameClosures.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/CheckStatic.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala | 4 ++++ compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala | 3 +++ .../src/dotty/tools/dotc/transform/ExtensionMethods.scala | 3 +++ .../src/dotty/tools/dotc/transform/HoistSuperArgs.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/LiftTry.scala | 3 +++ .../src/dotty/tools/dotc/transform/NormalizeFlags.scala | 5 ++++- compiler/src/dotty/tools/dotc/transform/TailRec.scala | 3 +++ compiler/src/dotty/tools/dotc/typer/RefChecks.scala | 4 ++++ tests/pickling/i3149.scala | 7 ------- 11 files changed, 33 insertions(+), 8 deletions(-) delete mode 100644 tests/pickling/i3149.scala diff --git a/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala b/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala index d8499369d051..eab5c4fdbe3b 100644 --- a/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala +++ b/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala @@ -29,6 +29,9 @@ class ByNameClosures extends TransformByNameApply with IdentityDenotTransformer override def phaseName: String = "byNameClosures" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def mkByNameClosure(arg: Tree, argType: Type)(implicit ctx: Context): Tree = { val meth = ctx.newSymbol( ctx.owner, nme.ANON_FUN, Synthetic | Method, MethodType(Nil, Nil, argType)) diff --git a/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala b/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala index b1dc3b578f41..efec81604e4c 100644 --- a/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala +++ b/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala @@ -39,6 +39,9 @@ class CheckStatic extends MiniPhaseTransform { thisTransformer => override def phaseName = "checkStatic" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformTemplate(tree: tpd.Template)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { val defns = tree.body.collect{case t: ValOrDefDef => t} var hadNonStaticField = false diff --git a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala index b4b274031b84..3388f99ee7e6 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala @@ -30,6 +30,10 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer { thisTransfo override def phaseName = "elimRepeated" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + + override def changesMembers = true // the phase adds vararg bridges def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = diff --git a/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala b/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala index 76ba7245d6c8..537d2817a200 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala @@ -24,6 +24,9 @@ import dotty.tools.dotc.util.Positions.Position class ExpandSAMs extends MiniPhaseTransform { thisTransformer => override def phaseName = "expandSAMs" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + import ast.tpd._ /** Is the SAMType `cls` also a SAM under the rules of the platform? */ diff --git a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala index f05afe82da48..292afa6096cb 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala @@ -42,6 +42,9 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful import tpd._ import ExtensionMethods._ + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + /** the following two members override abstract members in Transform */ override def phaseName: String = "extmethods" diff --git a/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala b/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala index 9ef36a7caf56..d778115138bc 100644 --- a/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala +++ b/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala @@ -42,6 +42,9 @@ class HoistSuperArgs extends MiniPhaseTransform with IdentityDenotTransformer { def phaseName = "hoistSuperArgs" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def runsAfter = Set(classOf[ByNameClosures]) // By name closures need to be introduced first in order to be hoisted out here. // There's an interaction with by name closures in that the marker diff --git a/compiler/src/dotty/tools/dotc/transform/LiftTry.scala b/compiler/src/dotty/tools/dotc/transform/LiftTry.scala index 278868131c20..4bc60eee8942 100644 --- a/compiler/src/dotty/tools/dotc/transform/LiftTry.scala +++ b/compiler/src/dotty/tools/dotc/transform/LiftTry.scala @@ -32,6 +32,9 @@ class LiftTry extends MiniPhase with IdentityDenotTransformer { thisTransform => class Transform(needLift: Boolean) extends TreeTransform { def phase = thisTransform + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def prepareForApply(tree: Apply)(implicit ctx: Context) = if (tree.fun.symbol.is(Label)) this else liftingTransform diff --git a/compiler/src/dotty/tools/dotc/transform/NormalizeFlags.scala b/compiler/src/dotty/tools/dotc/transform/NormalizeFlags.scala index 75584690409c..4f4790a46315 100644 --- a/compiler/src/dotty/tools/dotc/transform/NormalizeFlags.scala +++ b/compiler/src/dotty/tools/dotc/transform/NormalizeFlags.scala @@ -6,7 +6,7 @@ import DenotTransformers.SymTransformer import Phases.Phase import Contexts.Context import SymDenotations.SymDenotation -import TreeTransforms.MiniPhaseTransform +import TreeTransforms.{MiniPhaseTransform, TransformerInfo} import Flags._, Symbols._ /** 1. Widens all private[this] and protected[this] qualifiers to just private/protected @@ -17,6 +17,9 @@ import Flags._, Symbols._ class NormalizeFlags extends MiniPhaseTransform with SymTransformer { thisTransformer => override def phaseName = "normalizeFlags" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + def transformSym(ref: SymDenotation)(implicit ctx: Context) = { var newFlags = ref.flags &~ Local if (newFlags != ref.flags) ref.copySymDenotation(initFlags = newFlags) diff --git a/compiler/src/dotty/tools/dotc/transform/TailRec.scala b/compiler/src/dotty/tools/dotc/transform/TailRec.scala index 4f6d5dace29b..e08553280866 100644 --- a/compiler/src/dotty/tools/dotc/transform/TailRec.scala +++ b/compiler/src/dotty/tools/dotc/transform/TailRec.scala @@ -71,6 +71,9 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete override def phaseName: String = "tailrec" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + final val labelFlags = Flags.Synthetic | Flags.Label /** Symbols of methods that have @tailrec annotatios inside */ diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala index 2fe5a0a6f69c..129419e4534c 100644 --- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala +++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala @@ -806,6 +806,10 @@ class RefChecks extends MiniPhase { thisTransformer => class Transform(currentLevel: RefChecks.OptLevelInfo = RefChecks.NoLevelInfo) extends TreeTransform { def phase = thisTransformer + // Errors when run at end of group + //override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + // groupEndPhase + override def prepareForStats(trees: List[Tree])(implicit ctx: Context) = { // println(i"preparing for $trees%; %, owner = ${ctx.owner}") if (ctx.owner.isTerm) new Transform(new LevelInfo(currentLevel.levelAndIndex, trees)) diff --git a/tests/pickling/i3149.scala b/tests/pickling/i3149.scala deleted file mode 100644 index c582590822ef..000000000000 --- a/tests/pickling/i3149.scala +++ /dev/null @@ -1,7 +0,0 @@ -sealed class Foo - -class Test { - def f = { - class Bar extends Foo - } -} From 597de7727373485a4ea84b3ba6452fa87e73adb4 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 19 Oct 2017 11:02:05 +0200 Subject: [PATCH 06/20] Run all phases in third group at group end --- compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala | 3 +++ .../src/dotty/tools/dotc/transform/ShortcutImplicits.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/Splitter.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala | 3 +++ 7 files changed, 21 insertions(+) diff --git a/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala b/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala index 838286e81181..c1b155224a24 100644 --- a/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala +++ b/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala @@ -19,6 +19,9 @@ class CrossCastAnd extends MiniPhaseTransform { thisTransform => override def phaseName: String = "crossCast" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformSelect(tree: tpd.Select)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { lazy val qtype = tree.qualifier.tpe.widen diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala index 54e474888654..7e414ba57c89 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala @@ -42,6 +42,9 @@ class ExplicitOuter extends MiniPhaseTransform with InfoTransformer { thisTransf override def phaseName: String = "explicitOuter" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + /** List of names of phases that should have finished their processing of all compilation units * before this phase starts */ diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala index 3592471823ff..b0a94a30a6ff 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala @@ -28,6 +28,9 @@ class ExplicitSelf extends MiniPhaseTransform { thisTransform => override def phaseName = "explicitSelf" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformIdent(tree: Ident)(implicit ctx: Context, info: TransformerInfo) = tree.tpe match { case tp: ThisType => ctx.debuglog(s"owner = ${ctx.owner}, context = ${ctx}") diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala index 6e8f3141d39b..46aab3e7329b 100644 --- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala +++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala @@ -27,6 +27,9 @@ class PatternMatcher extends MiniPhaseTransform { override def runsAfter = Set(classOf[ElimRepeated]) override def runsAfterGroupsOf = Set(classOf[TailRec]) // tailrec is not capable of reversing the patmat tranformation made for tree + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformMatch(tree: Match)(implicit ctx: Context, info: TransformerInfo): Tree = { val translated = new Translator(tree.tpe, this).translateMatch(tree) diff --git a/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala b/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala index 91301c0cd86e..5fc4ef121f82 100644 --- a/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala +++ b/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala @@ -64,6 +64,9 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisTr class Transform extends TreeTransform { def phase = thisTransform + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def prepareForUnit(tree: Tree)(implicit ctx: Context) = new Transform /** A map to cache mapping local methods to their direct counterparts. diff --git a/compiler/src/dotty/tools/dotc/transform/Splitter.scala b/compiler/src/dotty/tools/dotc/transform/Splitter.scala index 3b6af780c6b9..a553dbd37573 100644 --- a/compiler/src/dotty/tools/dotc/transform/Splitter.scala +++ b/compiler/src/dotty/tools/dotc/transform/Splitter.scala @@ -13,6 +13,9 @@ class Splitter extends MiniPhaseTransform { thisTransform => override def phaseName: String = "splitter" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + /** Distribute arguments among splitted branches */ def distribute(tree: GenericApply[Type], rebuild: (Tree, List[Tree]) => Context => Tree)(implicit ctx: Context) = { def recur(fn: Tree): Tree = fn match { diff --git a/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala b/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala index 44d26e7dd3a4..66c8d01a05ec 100644 --- a/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala +++ b/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala @@ -45,6 +45,9 @@ class TryCatchPatterns extends MiniPhaseTransform { def phaseName: String = "tryCatchPatterns" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def runsAfter = Set(classOf[ElimRepeated]) override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match { From f9abe5b78c67230dec4a1a9d33e0ce2726457015 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 19 Oct 2017 11:32:36 +0200 Subject: [PATCH 07/20] Run most phases in 4th group at group end Only exception: elimByName, which produces errors if run at group end. --- .../src/dotty/tools/dotc/transform/AugmentScala2Traits.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/ElimByName.scala | 5 ++++- .../src/dotty/tools/dotc/transform/ElimOuterSelect.scala | 3 +++ .../dotty/tools/dotc/transform/FunctionXXLForwarders.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/Getters.scala | 3 +++ .../src/dotty/tools/dotc/transform/InterceptedMethods.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/PhantomArgLift.scala | 3 +++ .../src/dotty/tools/dotc/transform/PrimitiveForwarders.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala | 3 +++ .../src/dotty/tools/dotc/transform/VCInlineMethods.scala | 3 +++ .../src/dotty/tools/dotc/transform/localopt/Simplify.scala | 3 +++ 12 files changed, 37 insertions(+), 1 deletion(-) diff --git a/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala b/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala index c5226f756d63..2ab08f5e34f2 100644 --- a/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala +++ b/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala @@ -35,6 +35,9 @@ class AugmentScala2Traits extends MiniPhaseTransform with IdentityDenotTransform override def phaseName: String = "augmentScala2Traits" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def rewiredTarget(referenced: Symbol, derived: Symbol)(implicit ctx: Context) = NoSymbol override def transformTemplate(impl: Template)(implicit ctx: Context, info: TransformerInfo) = { diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala index 9b3008f9147f..9a656021e7d3 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala @@ -42,7 +42,10 @@ class ElimByName extends TransformByNameApply with InfoTransformer { thisTransfo override def phaseName: String = "elimByName" - override def runsAfterGroupsOf = Set(classOf[Splitter]) + //override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + // groupEndPhase + + override def runsAfterGroupsOf = Set(classOf[Splitter]) // I got errors running this phase in an earlier group, but I did not track them down. /** Map `tree` to `tree.apply()` is `ftree` was of ExprType and becomes now a function */ diff --git a/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala b/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala index 2ef5c8192bff..2d984996da17 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala @@ -17,6 +17,9 @@ class ElimOuterSelect extends MiniPhaseTransform { thisTransform => override def phaseName: String = "elimOuterSelect" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def runsAfterGroupsOf = Set(classOf[ExplicitOuter]) // ExplicitOuter needs to have run to completion before so that all classes // that need an outer accessor have one. diff --git a/compiler/src/dotty/tools/dotc/transform/FunctionXXLForwarders.scala b/compiler/src/dotty/tools/dotc/transform/FunctionXXLForwarders.scala index e67247fd8e32..e1d9bd54802d 100644 --- a/compiler/src/dotty/tools/dotc/transform/FunctionXXLForwarders.scala +++ b/compiler/src/dotty/tools/dotc/transform/FunctionXXLForwarders.scala @@ -27,6 +27,9 @@ class FunctionXXLForwarders extends MiniPhaseTransform with IdentityDenotTransfo override def phaseName: String = "functionXXLForwarders" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformTemplate(impl: Template)(implicit ctx: Context, info: TransformerInfo): Template = { def forwarderRhs(receiver: Tree, xsTree: Tree): Tree = { diff --git a/compiler/src/dotty/tools/dotc/transform/Getters.scala b/compiler/src/dotty/tools/dotc/transform/Getters.scala index 31171dfabe5e..8ec46222d6bf 100644 --- a/compiler/src/dotty/tools/dotc/transform/Getters.scala +++ b/compiler/src/dotty/tools/dotc/transform/Getters.scala @@ -51,6 +51,9 @@ class Getters extends MiniPhaseTransform with SymTransformer { thisTransform => override def phaseName = "getters" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = { def noGetterNeeded = d.is(NoGetterNeeded) || diff --git a/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala b/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala index b1f384586a0b..b5a2c4079ec1 100644 --- a/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala +++ b/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala @@ -43,6 +43,9 @@ class InterceptedMethods extends MiniPhaseTransform { override def phaseName: String = "intercepted" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + private[this] var primitiveGetClassMethods: Set[Symbol] = _ var Any_## : Symbol = _ // cached for performance reason diff --git a/compiler/src/dotty/tools/dotc/transform/PhantomArgLift.scala b/compiler/src/dotty/tools/dotc/transform/PhantomArgLift.scala index 6b823a8ce56f..02388640bb08 100644 --- a/compiler/src/dotty/tools/dotc/transform/PhantomArgLift.scala +++ b/compiler/src/dotty/tools/dotc/transform/PhantomArgLift.scala @@ -29,6 +29,9 @@ class PhantomArgLift extends MiniPhaseTransform { override def phaseName: String = "phantomArgLift" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + /** Check what the phase achieves, to be called at any point after it is finished. */ override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match { case tree: Apply => diff --git a/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala b/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala index fec7bd741dab..9ea65eaf5dcf 100644 --- a/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala +++ b/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala @@ -35,6 +35,9 @@ class PrimitiveForwarders extends MiniPhaseTransform with IdentityDenotTransform override def phaseName: String = "primitiveForwarders" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def runsAfter = Set(classOf[ResolveSuper]) override def changesMembers = true // the phase adds primitive forwarders diff --git a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala index 03a8f9678085..06677daf8be8 100644 --- a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala +++ b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala @@ -50,6 +50,9 @@ class ResolveSuper extends MiniPhaseTransform with IdentityDenotTransformer { th override def phaseName: String = "resolveSuper" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def runsAfter = Set(classOf[ElimByName], // verified empirically, need to figure out what the reason is. classOf[AugmentScala2Traits]) diff --git a/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala b/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala index 49ea695300bb..b0845d6e3c53 100644 --- a/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala +++ b/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala @@ -24,6 +24,9 @@ class SeqLiterals extends MiniPhaseTransform { override def phaseName = "seqLiterals" override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PatternMatcher]) + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match { case tpd: SeqLiteral => assert(tpd.isInstanceOf[JavaSeqLiteral]) case _ => diff --git a/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala b/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala index 146d30697bae..e94dd2f8a836 100644 --- a/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala +++ b/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala @@ -44,6 +44,9 @@ class VCInlineMethods extends MiniPhaseTransform with IdentityDenotTransformer { override def phaseName: String = "vcInlineMethods" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[ExtensionMethods], classOf[PatternMatcher], classOf[PhantomArgLift]) diff --git a/compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala index c78536c3b4fc..81d3e91c2e98 100644 --- a/compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala +++ b/compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala @@ -35,6 +35,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer { private[localopt] var SeqFactoryClass: Symbol = null private[localopt] var CommutativePrimitiveOperations: Set[Symbol] = null + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + /** The original intention is to run most optimizations both before and after erasure. * Erasure creates new inefficiencies as well as new optimization opportunities. * From d1711ea9b92dd436152ee47a6a4e951ea88d3bd3 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 19 Oct 2017 12:06:58 +0200 Subject: [PATCH 08/20] Run all phases in 6th group at group end --- compiler/src/dotty/tools/dotc/transform/Constructors.scala | 3 +++ .../src/dotty/tools/dotc/transform/ElimErasedValueType.scala | 3 +++ .../src/dotty/tools/dotc/transform/FunctionalInterfaces.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/GetClass.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/LazyVals.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/Memoize.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/Mixin.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala | 3 +++ .../src/dotty/tools/dotc/transform/VCElideAllocations.scala | 3 +++ 9 files changed, 27 insertions(+) diff --git a/compiler/src/dotty/tools/dotc/transform/Constructors.scala b/compiler/src/dotty/tools/dotc/transform/Constructors.scala index 969f4f548a07..c1352e0dad2a 100644 --- a/compiler/src/dotty/tools/dotc/transform/Constructors.scala +++ b/compiler/src/dotty/tools/dotc/transform/Constructors.scala @@ -39,6 +39,9 @@ class Constructors extends MiniPhaseTransform with IdentityDenotTransformer { th // performed before the rhs undergoes the owner change. This would lead // to more symbols being retained as parameters. Test case in run/capturing.scala. + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + /** The private vals that are known to be retained as class fields */ private val retainedPrivateVals = mutable.Set[Symbol]() diff --git a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala index 913264081207..4d0a5d9d5164 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala @@ -23,6 +23,9 @@ class ElimErasedValueType extends MiniPhaseTransform with InfoTransformer { override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure]) + //override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + // groupEndPhase + def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = sym match { case sym: ClassSymbol if sym is ModuleClass => sym.companionClass match { diff --git a/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala b/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala index 8166e4f35675..199ba1644a88 100644 --- a/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala +++ b/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala @@ -26,6 +26,9 @@ class FunctionalInterfaces extends MiniPhaseTransform { def phaseName: String = "functionalInterfaces" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + val functionName = "JFunction".toTermName val functionPackage = "scala.compat.java8.".toTermName diff --git a/compiler/src/dotty/tools/dotc/transform/GetClass.scala b/compiler/src/dotty/tools/dotc/transform/GetClass.scala index 6a9a5fda2019..221b54f4d638 100644 --- a/compiler/src/dotty/tools/dotc/transform/GetClass.scala +++ b/compiler/src/dotty/tools/dotc/transform/GetClass.scala @@ -20,6 +20,9 @@ class GetClass extends MiniPhaseTransform { override def phaseName: String = "getClass" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + // getClass transformation should be applied to specialized methods override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure], classOf[FunctionalInterfaces]) diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala index 9afb3051478c..47ad3217b70d 100644 --- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala +++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala @@ -38,6 +38,9 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer { override def phaseName: String = "LazyVals" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + /** List of names of phases that should have finished processing of tree * before this phase starts processing same tree */ override def runsAfter = Set(classOf[Mixin]) diff --git a/compiler/src/dotty/tools/dotc/transform/Memoize.scala b/compiler/src/dotty/tools/dotc/transform/Memoize.scala index 44bb6bd73c88..374919fca5c1 100644 --- a/compiler/src/dotty/tools/dotc/transform/Memoize.scala +++ b/compiler/src/dotty/tools/dotc/transform/Memoize.scala @@ -37,6 +37,9 @@ import Decorators._ override def phaseName = "memoize" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + /* Makes sure that, after getters and constructors gen, there doesn't * exist non-deferred definitions that are not implemented. */ override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = { diff --git a/compiler/src/dotty/tools/dotc/transform/Mixin.scala b/compiler/src/dotty/tools/dotc/transform/Mixin.scala index fc6cc67eba18..753b90cad88b 100644 --- a/compiler/src/dotty/tools/dotc/transform/Mixin.scala +++ b/compiler/src/dotty/tools/dotc/transform/Mixin.scala @@ -98,6 +98,9 @@ class Mixin extends MiniPhaseTransform with SymTransformer { thisTransform => override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure]) + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def changesMembers = true // the phase adds implementions of mixin accessors override def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation = diff --git a/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala b/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala index fdee076b452f..2be7da4deb48 100644 --- a/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala +++ b/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala @@ -24,6 +24,9 @@ class NonLocalReturns extends MiniPhaseTransform { thisTransformer => override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[ElimByName]) + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + private def ensureConforms(tree: Tree, pt: Type)(implicit ctx: Context) = if (tree.tpe <:< pt) tree else Erasure.Boxing.adaptToType(tree, pt) diff --git a/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala b/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala index 1582158acaaa..5fc98eeb5847 100644 --- a/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala +++ b/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala @@ -20,6 +20,9 @@ class VCElideAllocations extends MiniPhaseTransform with IdentityDenotTransforme override def phaseName: String = "vcElideAllocations" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[ElimErasedValueType]) override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = From b8883b2866b30495f86afc0e7e3f4052a23efc34 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 19 Oct 2017 16:19:17 +0200 Subject: [PATCH 09/20] Move Flatten and RestoreScopes to last group LambdaLift cannot run at same phase as Flatten, so it's better to move Flatten one phase later. Some check files that dependent on the order in which symbols were accessed needed to be updated. --- compiler/src/dotty/tools/dotc/Compiler.scala | 8 ++++---- .../src/dotty/tools/dotc/transform/RenameLifted.scala | 3 ++- .../src/dotty/tools/dotc/transform/RestoreScopes.scala | 3 +++ 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala index 4e6eeef20dd5..590fe38d4530 100644 --- a/compiler/src/dotty/tools/dotc/Compiler.scala +++ b/compiler/src/dotty/tools/dotc/Compiler.scala @@ -98,10 +98,10 @@ class Compiler { 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 - 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 RenameLifted, // Renames lifted classes to local numbering scheme + new ElimStaticThis), // Replace `this` references to static objects by global identifiers + List(new Flatten, // Lift all inner classes to package scope + new RestoreScopes, // Repair scopes rendered invalid by moving definitions in prior phases of the group + new RenameLifted, // Renames lifted classes to local numbering scheme new TransformWildcards, // Replace wildcards with default values new MoveStatics, // Move static methods to companion classes new ExpandPrivate, // Widen private definitions accessed from nested classes diff --git a/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala b/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala index a9b4fda27eab..65d47bbe189f 100644 --- a/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala +++ b/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala @@ -16,7 +16,8 @@ class RenameLifted extends MiniPhaseTransform with SymTransformer { thisTransfor override def phaseName = "renameLifted" - override def runsAfterGroupsOf: Set[Class[_ <: Phases.Phase]] = Set(classOf[RestoreScopes]) + // Not clear why this should run after restoreScopes + // override def runsAfterGroupsOf: Set[Class[_ <: Phases.Phase]] = Set(classOf[RestoreScopes]) override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = groupEndPhase diff --git a/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala b/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala index 8d2b8e25a61a..6fa73be5e958 100644 --- a/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala +++ b/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala @@ -24,6 +24,9 @@ class RestoreScopes extends MiniPhaseTransform with IdentityDenotTransformer { t override def changesMembers = true // the phase affects scopes, applying tree transformations of previous phases + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + /* Note: We need to wait until we see a package definition because * DropEmptyConstructors changes template members when analyzing the * enclosing package definitions. So by the time RestoreScopes gets to From 8b256ad78f2b73becde93faca68d1d8fd2b9c1f4 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 19 Oct 2017 16:40:25 +0200 Subject: [PATCH 10/20] Run LambdaLift at group end The other phase, LinkScala2Impls cannot yet be run at group end - it produces errors if one tries. --- compiler/src/dotty/tools/dotc/transform/LambdaLift.scala | 3 +++ compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala | 3 +++ 2 files changed, 6 insertions(+) diff --git a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala index 23d58c035577..83ed13295230 100644 --- a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala +++ b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala @@ -76,6 +76,9 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform class LambdaLifter extends TreeTransform { override def phase = thisTransform + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + private type SymSet = TreeSet[Symbol] /** A map storing free variables of functions and classes */ diff --git a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala index 180e48e5f84b..6b753e0816a7 100644 --- a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala +++ b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala @@ -48,6 +48,9 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisTran class Transform extends TreeTransform { def phase = thisTransform + //override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + // groupEndPhase + /** Copy definitions from implementation class to trait itself */ private def augmentScala_2_12_Trait(mixin: ClassSymbol)(implicit ctx: Context): Unit = { def info_2_12(sym: Symbol) = sym.info match { From daff2878bffabeaf28febd1e3a1a5769eb8d91a1 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 19 Oct 2017 17:52:24 +0200 Subject: [PATCH 11/20] Fix -Ycheck options Instead of restoreScopes, use elimStaticThis, which is the new end of the group. --- compiler/test/dotc/tests.scala | 4 ++-- compiler/test/dotty/tools/vulpix/TestConfiguration.scala | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/compiler/test/dotc/tests.scala b/compiler/test/dotc/tests.scala index a21496ed0e8f..39ab4da8b9bd 100644 --- a/compiler/test/dotc/tests.scala +++ b/compiler/test/dotc/tests.scala @@ -69,8 +69,8 @@ class tests extends CompilerTest { } implicit val defaultOptions: List[String] = noCheckOptions ++ { - if (dotty.Properties.isRunByDrone) List("-Ycheck:tailrec,resolveSuper,erasure,mixin,getClass,restoreScopes,labelDef") // should be Ycheck:all, but #725 - else List("-Ycheck:tailrec,resolveSuper,mixin,restoreScopes,labelDef,simplify") + if (dotty.Properties.isRunByDrone) List("-Ycheck:tailrec,resolveSuper,erasure,mixin,getClass,elimStaticThis,labelDef") // should be Ycheck:all, but #725 + else List("-Ycheck:tailrec,resolveSuper,mixin,elimStaticThis,labelDef,simplify") } ++ checkOptions ++ classPath val testPickling = List("-Xprint-types", "-Ytest-pickler", "-Ystop-after:pickler", "-Yprintpos") diff --git a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala index b0a31e6e1ce8..7c25cc56ea9f 100644 --- a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala +++ b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala @@ -42,7 +42,7 @@ object TestConfiguration { } mkString(":") } - val yCheckOptions = Array("-Ycheck:tailrec,resolveSuper,erasure,mixin,getClass,restoreScopes,labelDef") + val yCheckOptions = Array("-Ycheck:tailrec,resolveSuper,erasure,mixin,getClass,elimStaticThis,labelDef") val basicDefaultOptions = checkOptions ++ noCheckOptions ++ yCheckOptions val defaultUnoptimised = TestFlags(classPath, basicDefaultOptions) From ca28446e3c6b917086531ac59d7faf048c73ae99 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Fri, 20 Oct 2017 10:18:25 +0200 Subject: [PATCH 12/20] Do relaxedTyping everywhere If all phases run at group end, any phase that adds or removes method parameters makes all phases run before it in the same group have the wrong number of parameters when type assigning an Apply or TypeApply. Previously this was allowed only if relaxedTyping was true. Now it is allowed everywhere. We should still be able to catch any errors in the transformer logic using Ycheck. With this change, LinkScala2Impls can now be run at group end. --- .../src/dotty/tools/dotc/core/Phases.scala | 5 ---- .../tools/dotc/transform/LambdaLift.scala | 2 -- .../dotc/transform/LinkScala2Impls.scala | 4 +-- .../dotty/tools/dotc/typer/TypeAssigner.scala | 28 ++++++++++--------- 4 files changed, 17 insertions(+), 22 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala index 92ed5d75a831..10c7b7416325 100644 --- a/compiler/src/dotty/tools/dotc/core/Phases.scala +++ b/compiler/src/dotty/tools/dotc/core/Phases.scala @@ -298,11 +298,6 @@ object Phases { */ def checkPostCondition(tree: tpd.Tree)(implicit ctx: Context): Unit = () - /** If set, allow missing or superfluous arguments in applications - * and type applications. - */ - def relaxedTyping: Boolean = false - /** Is this phase the standard typerphase? True for FrontEnd, but * not for other first phases (such as FromTasty). The predicate * is tested in some places that perform checks and corrections. It's diff --git a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala index 83ed13295230..34afd87dbd42 100644 --- a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala +++ b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala @@ -64,8 +64,6 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform val phaseName: String = "lambdaLift" val treeTransform = new LambdaLifter - override def relaxedTyping = true - override def runsAfterGroupsOf: Set[Class[_ <: Phase]] = Set(classOf[Constructors], classOf[HoistSuperArgs]) // Constructors has to happen before LambdaLift because the lambda lift logic // becomes simpler if it can assume that parameter accessors have already been diff --git a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala index 6b753e0816a7..be4a79674d89 100644 --- a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala +++ b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala @@ -48,8 +48,8 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisTran class Transform extends TreeTransform { def phase = thisTransform - //override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - // groupEndPhase + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase /** Copy definitions from implementation class to trait itself */ private def augmentScala_2_12_Trait(mixin: ClassSymbol)(implicit ctx: Context): Unit = { diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala index 93cb4093f68c..09d380eb06f9 100644 --- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala +++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala @@ -334,21 +334,23 @@ trait TypeAssigner { else tp.substParam(pref, SkolemType(argType.widen)) } + /** Substitute types of all arguments `args` for corresponding `params` in `tp`. + * The number of parameters `params` may exceed the number of arguments. + * In this case, only the common prefix is substituted. + */ + def safeSubstParams(tp: Type, params: List[ParamRef], argTypes: List[Type])(implicit ctx: Context): Type = argTypes match { + case argType :: argTypes1 => + val tp1 = safeSubstParam(tp, params.head, argType) + safeSubstParams(tp1, params.tail, argTypes1) + case Nil => + tp + } + def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(implicit ctx: Context) = { val ownType = fn.tpe.widen match { case fntpe: MethodType => - def safeSubstParams(tp: Type, params: List[ParamRef], args: List[Tree]): Type = params match { - case param :: params1 => - val tp1 = safeSubstParam(tp, param, args.head.tpe) - safeSubstParams(tp1, params1, args.tail) - case Nil => - tp - } - if (sameLength(fntpe.paramInfos, args) || ctx.phase.prev.relaxedTyping) - if (fntpe.isDependent) safeSubstParams(fntpe.resultType, fntpe.paramRefs, args) - else fntpe.resultType - else - errorType(i"wrong number of arguments for $fntpe: ${fn.tpe}, expected: ${fntpe.paramInfos.length}, found: ${args.length}", tree.pos) + if (fntpe.isDependent) safeSubstParams(fntpe.resultType, fntpe.paramRefs, args.tpes) + else fntpe.resultType case t => errorType(err.takesNoParamsStr(fn, ""), tree.pos) } @@ -404,7 +406,7 @@ trait TypeAssigner { } else { val argTypes = preCheckKinds(args, pt.paramInfos).tpes - if (sameLength(argTypes, paramNames) || ctx.phase.prev.relaxedTyping) pt.instantiate(argTypes) + if (sameLength(argTypes, paramNames)) pt.instantiate(argTypes) else wrongNumberOfTypeArgs(fn.tpe, pt.typeParams, args, tree.pos) } case _ => From 354addd87a51a5cf17ac4d98e334bf3ed4be41f0 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Fri, 20 Oct 2017 10:19:52 +0200 Subject: [PATCH 13/20] Simplify TailRec --- .../dotty/tools/dotc/transform/TailRec.scala | 121 +++++++++--------- 1 file changed, 57 insertions(+), 64 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/transform/TailRec.scala b/compiler/src/dotty/tools/dotc/transform/TailRec.scala index e08553280866..614dc38e9de3 100644 --- a/compiler/src/dotty/tools/dotc/transform/TailRec.scala +++ b/compiler/src/dotty/tools/dotc/transform/TailRec.scala @@ -6,7 +6,6 @@ import ast.{TreeTypeMap, tpd} import core._ import Contexts.Context import Decorators._ -import DenotTransformers.DenotTransformer import Denotations.SingleDenotation import Symbols._ import Types._ @@ -62,13 +61,11 @@ import TreeTransforms.{MiniPhaseTransform, TransformerInfo} * self recursive functions, that's why it's renamed to tailrec *

*/ -class TailRec extends MiniPhaseTransform with DenotTransformer with FullParameterization { thisTransform => +class TailRec extends MiniPhaseTransform with FullParameterization { thisTransform => import TailRec._ import dotty.tools.dotc.ast.tpd._ - override def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref - override def phaseName: String = "tailrec" override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = @@ -98,71 +95,69 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete else ctx.newSymbol(method, name.toTermName, labelFlags, method.info) } + /** Note: This method should be run atGroupEnd */ override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { val sym = tree.symbol tree match { case dd@DefDef(name, tparams, vparamss0, tpt, _) if (sym.isEffectivelyFinal) && !((sym is Flags.Accessor) || (dd.rhs eq EmptyTree) || (sym is Flags.Label)) => val mandatory = sym.hasAnnotation(defn.TailrecAnnot) - atGroupEnd { implicit ctx: Context => - - cpy.DefDef(dd)(rhs = { - - val defIsTopLevel = sym.owner.isClass - val origMeth = sym - val label = mkLabel(sym, abstractOverClass = defIsTopLevel) - val owner = ctx.owner.enclosingClass.asClass - val thisTpe = owner.thisType.widen - - var rewrote = false - - // Note: this can be split in two separate transforms(in different groups), - // than first one will collect info about which transformations and rewritings should be applied - // and second one will actually apply, - // now this speculatively transforms tree and throws away result in many cases - val rhsSemiTransformed = { - val transformer = new TailRecElimination(origMeth, dd.tparams, owner, thisTpe, mandatory, label, abstractOverClass = defIsTopLevel) - val rhs = atGroupEnd(implicit ctx => transformer.transform(dd.rhs)) - rewrote = transformer.rewrote - rhs - } + cpy.DefDef(dd)(rhs = { + + val defIsTopLevel = sym.owner.isClass + val origMeth = sym + val label = mkLabel(sym, abstractOverClass = defIsTopLevel) + val owner = ctx.owner.enclosingClass.asClass + val thisTpe = owner.thisType.widen + + var rewrote = false + + // Note: this can be split in two separate transforms(in different groups), + // than first one will collect info about which transformations and rewritings should be applied + // and second one will actually apply, + // now this speculatively transforms tree and throws away result in many cases + val rhsSemiTransformed = { + val transformer = new TailRecElimination(origMeth, dd.tparams, owner, thisTpe, mandatory, label, abstractOverClass = defIsTopLevel) + val rhs = atGroupEnd(implicit ctx => transformer.transform(dd.rhs)) + rewrote = transformer.rewrote + rhs + } - if (rewrote) { - val dummyDefDef = cpy.DefDef(tree)(rhs = rhsSemiTransformed) - if (tree.symbol.owner.isClass) { - val labelDef = fullyParameterizedDef(label, dummyDefDef, abstractOverClass = defIsTopLevel) - val call = forwarder(label, dd, abstractOverClass = defIsTopLevel, liftThisType = true) - Block(List(labelDef), call) - } else { // inner method. Tail recursion does not change `this` - val labelDef = polyDefDef(label, trefs => vrefss => { - val origMeth = tree.symbol - val origTParams = tree.tparams.map(_.symbol) - val origVParams = tree.vparamss.flatten map (_.symbol) - new TreeTypeMap( - typeMap = identity(_) - .substDealias(origTParams, trefs) - .subst(origVParams, vrefss.flatten.map(_.tpe)), - oldOwners = origMeth :: Nil, - newOwners = label :: Nil - ).transform(rhsSemiTransformed) - }) - val callIntoLabel = ( - if (dd.tparams.isEmpty) ref(label) - else ref(label).appliedToTypes(dd.tparams.map(_.tpe)) - ).appliedToArgss(vparamss0.map(_.map(x=> ref(x.symbol)))) - Block(List(labelDef), callIntoLabel) - }} else { - if (mandatory) ctx.error( - "TailRec optimisation not applicable, method not tail recursive", - // FIXME: want to report this error on `dd.namePos`, but - // because of extension method getting a weird pos, it is - // better to report on symbol so there's no overlap - sym.pos - ) - dd.rhs - } - }) - } + if (rewrote) { + val dummyDefDef = cpy.DefDef(tree)(rhs = rhsSemiTransformed) + if (tree.symbol.owner.isClass) { + val labelDef = fullyParameterizedDef(label, dummyDefDef, abstractOverClass = defIsTopLevel) + val call = forwarder(label, dd, abstractOverClass = defIsTopLevel, liftThisType = true) + Block(List(labelDef), call) + } else { // inner method. Tail recursion does not change `this` + val labelDef = polyDefDef(label, trefs => vrefss => { + val origMeth = tree.symbol + val origTParams = tree.tparams.map(_.symbol) + val origVParams = tree.vparamss.flatten map (_.symbol) + new TreeTypeMap( + typeMap = identity(_) + .substDealias(origTParams, trefs) + .subst(origVParams, vrefss.flatten.map(_.tpe)), + oldOwners = origMeth :: Nil, + newOwners = label :: Nil + ).transform(rhsSemiTransformed) + }) + val callIntoLabel = ( + if (dd.tparams.isEmpty) ref(label) + else ref(label).appliedToTypes(dd.tparams.map(_.tpe)) + ).appliedToArgss(vparamss0.map(_.map(x=> ref(x.symbol)))) + Block(List(labelDef), callIntoLabel) + }} else { + if (mandatory) ctx.error( + "TailRec optimisation not applicable, method not tail recursive", + // FIXME: want to report this error on `dd.namePos`, but + // because of extension method getting a weird pos, it is + // better to report on symbol so there's no overlap + sym.pos + ) + dd.rhs + } + }) case d: DefDef if d.symbol.hasAnnotation(defn.TailrecAnnot) || methodsWithInnerAnnots.contains(d.symbol) => ctx.error("TailRec optimisation not applicable, method is neither private nor final so can be overridden", sym.pos) d @@ -242,8 +237,6 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete continue } - - if (isRecursiveCall) { if (ctx.tailPos) { val receiverIsSame = enclosingClass.appliedRef.widenDealias =:= recvWiden From 48a39b4cc840c8b49a68957dbd3f88106a6e45c6 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Fri, 20 Oct 2017 12:17:17 +0200 Subject: [PATCH 14/20] Remove conflict between ElimErasedValueTypes and CapturedVars --- compiler/src/dotty/tools/dotc/transform/CapturedVars.scala | 4 ++-- .../src/dotty/tools/dotc/transform/ElimErasedValueType.scala | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/transform/CapturedVars.scala b/compiler/src/dotty/tools/dotc/transform/CapturedVars.scala index 07cbceb7b2e4..f0e69330adab 100644 --- a/compiler/src/dotty/tools/dotc/transform/CapturedVars.scala +++ b/compiler/src/dotty/tools/dotc/transform/CapturedVars.scala @@ -91,7 +91,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisTransfo } override def prepareForValDef(vdef: ValDef)(implicit ctx: Context) = { - val sym = vdef.symbol + val sym = vdef.symbol(ctx.withPhase(thisTransform)) if (captured contains sym) { val newd = sym.denot(ctx.withPhase(thisTransform)).copySymDenotation( info = refClass(sym.info.classSymbol, sym.hasAnnotation(defn.VolatileAnnot)).typeRef, @@ -119,7 +119,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisTransfo override def transformIdent(id: Ident)(implicit ctx: Context, info: TransformerInfo): Tree = { val vble = id.symbol if (captured(vble)) - (id select nme.elem).ensureConforms(vble.denot(ctx.withPhase(thisTransform)).info) + id.select(nme.elem).ensureConforms(vble.denot(ctx.withPhase(thisTransform)).info) else id } diff --git a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala index 4d0a5d9d5164..037321b6f8ca 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala @@ -23,8 +23,8 @@ class ElimErasedValueType extends MiniPhaseTransform with InfoTransformer { override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure]) - //override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - // groupEndPhase + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = sym match { case sym: ClassSymbol if sym is ModuleClass => From 49f183a2007526c153fb92f493e7fe2fe6f9bc3d Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Fri, 20 Oct 2017 18:09:57 +0200 Subject: [PATCH 15/20] Run RefChecks at group end Move to end of group. Needed a fix in ExtensionMethods to work correctly. Before the fix, extension methods got wrong flags. --- compiler/src/dotty/tools/dotc/Compiler.scala | 4 ++-- compiler/src/dotty/tools/dotc/transform/ClassOf.scala | 3 +++ .../src/dotty/tools/dotc/transform/ExtensionMethods.scala | 2 +- compiler/src/dotty/tools/dotc/typer/RefChecks.scala | 5 ++--- 4 files changed, 8 insertions(+), 6 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala index 590fe38d4530..f80e01a00d91 100644 --- a/compiler/src/dotty/tools/dotc/Compiler.scala +++ b/compiler/src/dotty/tools/dotc/Compiler.scala @@ -53,7 +53,6 @@ class Compiler { new ElimJavaPackages), // Eliminate syntactic references to Java packages List(new CheckStatic, // Check restrictions that apply to @static members new ElimRepeated, // Rewrite vararg parameters and arguments - new RefChecks, // Various checks mostly related to abstract members and overriding 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 @@ -61,7 +60,8 @@ class Compiler { 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 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. diff --git a/compiler/src/dotty/tools/dotc/transform/ClassOf.scala b/compiler/src/dotty/tools/dotc/transform/ClassOf.scala index e7b6977c7b5b..7d275e49bc9c 100644 --- a/compiler/src/dotty/tools/dotc/transform/ClassOf.scala +++ b/compiler/src/dotty/tools/dotc/transform/ClassOf.scala @@ -21,6 +21,9 @@ class ClassOf extends MiniPhaseTransform { override def phaseName: String = "classOf" + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase + override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree = if (tree.symbol eq defn.Predef_classOf) { val targ = tree.args.head.tpe diff --git a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala index 292afa6096cb..900a02b6fd33 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala @@ -134,7 +134,7 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful private def createExtensionMethod(imeth: Symbol, staticClass: Symbol)(implicit ctx: Context): TermSymbol = { val extensionName = extensionNames(imeth).head.toTermName val extensionMeth = ctx.newSymbol(staticClass, extensionName, - imeth.flags | Final &~ (Override | Protected | AbsOverride), + (imeth.flags | Final) &~ (Override | Protected | AbsOverride), fullyParameterizedType(imeth.info, imeth.owner.asClass), privateWithin = imeth.privateWithin, coord = imeth.coord) extensionMeth.addAnnotations(imeth.annotations)(ctx.withPhase(thisTransformer)) diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala index 129419e4534c..dd368806bcf4 100644 --- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala +++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala @@ -806,9 +806,8 @@ class RefChecks extends MiniPhase { thisTransformer => class Transform(currentLevel: RefChecks.OptLevelInfo = RefChecks.NoLevelInfo) extends TreeTransform { def phase = thisTransformer - // Errors when run at end of group - //override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - // groupEndPhase + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase override def prepareForStats(trees: List[Tree])(implicit ctx: Context) = { // println(i"preparing for $trees%; %, owner = ${ctx.owner}") From d02e4f8214dd66e9fe6eed725992ea33681ee0f2 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Fri, 20 Oct 2017 18:57:40 +0200 Subject: [PATCH 16/20] Make elimByName run at group end --- .../dotty/tools/dotc/transform/ElimByName.scala | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala index 9a656021e7d3..f2f02b286a7d 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala @@ -42,15 +42,16 @@ class ElimByName extends TransformByNameApply with InfoTransformer { thisTransfo override def phaseName: String = "elimByName" - //override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - // groupEndPhase + override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = + groupEndPhase override def runsAfterGroupsOf = Set(classOf[Splitter]) // I got errors running this phase in an earlier group, but I did not track them down. /** Map `tree` to `tree.apply()` is `ftree` was of ExprType and becomes now a function */ private def applyIfFunction(tree: Tree, ftree: Tree)(implicit ctx: Context) = - if (isByNameRef(ftree)) tree.select(defn.Function0_apply).appliedToNone + if (isByNameRef(ftree)) + ctx.atPhase(next) { implicit ctx => tree.select(defn.Function0_apply).appliedToNone } else tree override def transformIdent(tree: Ident)(implicit ctx: Context, info: TransformerInfo): Tree = @@ -68,9 +69,11 @@ class ElimByName extends TransformByNameApply with InfoTransformer { thisTransfo } override def transformValDef(tree: ValDef)(implicit ctx: Context, info: TransformerInfo): Tree = - if (exprBecomesFunction(tree.symbol)) - cpy.ValDef(tree)(tpt = tree.tpt.withType(tree.symbol.info)) - else tree + ctx.atPhase(next) { implicit ctx => + if (exprBecomesFunction(tree.symbol)) + cpy.ValDef(tree)(tpt = tree.tpt.withType(tree.symbol.info)) + else tree + } def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = tp match { case ExprType(rt) if exprBecomesFunction(sym) => defn.FunctionOf(Nil, rt) From 5a2ae35e0dce9f0d3dac33f7477ee4ab40b58274 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Fri, 20 Oct 2017 19:28:09 +0200 Subject: [PATCH 17/20] Run all miniphases at group end We now have all miniphases running at group end. We can remove the infrastructure to enable other behavior. If some parts of some transformations need to run at a different phase than group end, we can always to `ctx.atPhase { ... }`. --- .../tools/backend/jvm/CollectSuperCalls.scala | 3 - .../dotty/tools/backend/jvm/LabelDefs.scala | 3 - .../dotc/transform/AugmentScala2Traits.scala | 3 - .../tools/dotc/transform/ByNameClosures.scala | 3 - .../tools/dotc/transform/CheckReentrant.scala | 3 - .../tools/dotc/transform/CheckStatic.scala | 3 - .../dotty/tools/dotc/transform/ClassOf.scala | 3 - .../dotc/transform/CollectEntryPoints.scala | 3 - .../tools/dotc/transform/Constructors.scala | 3 - .../tools/dotc/transform/CrossCastAnd.scala | 3 - .../tools/dotc/transform/DropInlined.scala | 3 - .../tools/dotc/transform/ElimByName.scala | 5 +- .../dotc/transform/ElimErasedValueType.scala | 3 - .../dotc/transform/ElimOuterSelect.scala | 3 - .../tools/dotc/transform/ElimRepeated.scala | 4 - .../tools/dotc/transform/ExpandPrivate.scala | 3 - .../tools/dotc/transform/ExpandSAMs.scala | 3 - .../tools/dotc/transform/ExplicitOuter.scala | 3 - .../tools/dotc/transform/ExplicitSelf.scala | 3 - .../dotc/transform/ExtensionMethods.scala | 3 - .../tools/dotc/transform/FirstTransform.scala | 3 - .../transform/FunctionXXLForwarders.scala | 3 - .../dotc/transform/FunctionalInterfaces.scala | 3 - .../dotty/tools/dotc/transform/GetClass.scala | 3 - .../dotty/tools/dotc/transform/Getters.scala | 3 - .../tools/dotc/transform/HoistSuperArgs.scala | 3 - .../dotc/transform/InterceptedMethods.scala | 3 - .../tools/dotc/transform/LambdaLift.scala | 3 - .../dotty/tools/dotc/transform/LazyVals.scala | 3 - .../dotty/tools/dotc/transform/LiftTry.scala | 3 - .../dotc/transform/LinkScala2Impls.scala | 3 - .../dotty/tools/dotc/transform/Memoize.scala | 3 - .../dotty/tools/dotc/transform/Mixin.scala | 3 - .../tools/dotc/transform/MoveStatics.scala | 3 - .../dotc/transform/NonLocalReturns.scala | 3 - .../tools/dotc/transform/NormalizeFlags.scala | 3 - .../tools/dotc/transform/PatternMatcher.scala | 3 - .../tools/dotc/transform/PhantomArgLift.scala | 3 - .../dotc/transform/PrimitiveForwarders.scala | 3 - .../tools/dotc/transform/RenameLifted.scala | 3 - .../tools/dotc/transform/ResolveSuper.scala | 3 - .../tools/dotc/transform/RestoreScopes.scala | 3 - .../tools/dotc/transform/SelectStatic.scala | 3 - .../tools/dotc/transform/SeqLiterals.scala | 3 - .../dotc/transform/ShortcutImplicits.scala | 3 - .../dotty/tools/dotc/transform/Splitter.scala | 3 - .../dotty/tools/dotc/transform/TailRec.scala | 5 +- .../dotc/transform/TransformWildcards.scala | 3 - .../tools/dotc/transform/TreeTransform.scala | 78 ++++++++++--------- .../dotc/transform/TryCatchPatterns.scala | 3 - .../dotc/transform/VCElideAllocations.scala | 3 - .../dotc/transform/VCInlineMethods.scala | 3 - .../dotc/transform/localopt/Simplify.scala | 3 - .../dotty/tools/dotc/typer/RefChecks.scala | 3 - 54 files changed, 43 insertions(+), 199 deletions(-) diff --git a/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala b/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala index d858e8f671b7..8285bfe4b5e9 100644 --- a/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala +++ b/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala @@ -22,9 +22,6 @@ class CollectSuperCalls extends MiniPhaseTransform { def phaseName: String = "collectSuperCalls" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformSelect(tree: Select)(implicit ctx: Context, info: TransformerInfo): Tree = { tree.qualifier match { case sup: Super => diff --git a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala index 60b2a3be0411..eabe1d3b0c3b 100644 --- a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala +++ b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala @@ -88,9 +88,6 @@ class LabelDefs extends MiniPhaseTransform { val beingAppended = new mutable.HashSet[Symbol]() var labelLevel = 0 - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { if (tree.symbol is Flags.Label) tree else { diff --git a/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala b/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala index 2ab08f5e34f2..c5226f756d63 100644 --- a/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala +++ b/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala @@ -35,9 +35,6 @@ class AugmentScala2Traits extends MiniPhaseTransform with IdentityDenotTransform override def phaseName: String = "augmentScala2Traits" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def rewiredTarget(referenced: Symbol, derived: Symbol)(implicit ctx: Context) = NoSymbol override def transformTemplate(impl: Template)(implicit ctx: Context, info: TransformerInfo) = { diff --git a/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala b/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala index eab5c4fdbe3b..d8499369d051 100644 --- a/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala +++ b/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala @@ -29,9 +29,6 @@ class ByNameClosures extends TransformByNameApply with IdentityDenotTransformer override def phaseName: String = "byNameClosures" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def mkByNameClosure(arg: Tree, argType: Type)(implicit ctx: Context): Tree = { val meth = ctx.newSymbol( ctx.owner, nme.ANON_FUN, Synthetic | Method, MethodType(Nil, Nil, argType)) diff --git a/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala b/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala index 2da9ca0b6a32..92228b9a8463 100644 --- a/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala +++ b/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala @@ -45,9 +45,6 @@ class CheckReentrant extends MiniPhaseTransform { thisTransformer => override def phaseName = "checkReentrant" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - private[this] var shared: Set[Symbol] = Set() private[this] var seen: Set[ClassSymbol] = Set() private[this] var indent: Int = 0 diff --git a/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala b/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala index efec81604e4c..b1dc3b578f41 100644 --- a/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala +++ b/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala @@ -39,9 +39,6 @@ class CheckStatic extends MiniPhaseTransform { thisTransformer => override def phaseName = "checkStatic" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformTemplate(tree: tpd.Template)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { val defns = tree.body.collect{case t: ValOrDefDef => t} var hadNonStaticField = false diff --git a/compiler/src/dotty/tools/dotc/transform/ClassOf.scala b/compiler/src/dotty/tools/dotc/transform/ClassOf.scala index 7d275e49bc9c..e7b6977c7b5b 100644 --- a/compiler/src/dotty/tools/dotc/transform/ClassOf.scala +++ b/compiler/src/dotty/tools/dotc/transform/ClassOf.scala @@ -21,9 +21,6 @@ class ClassOf extends MiniPhaseTransform { override def phaseName: String = "classOf" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree = if (tree.symbol eq defn.Predef_classOf) { val targ = tree.args.head.tpe diff --git a/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala b/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala index 1463a167579e..893e79ce0282 100644 --- a/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala +++ b/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala @@ -24,9 +24,6 @@ import dotty.tools.dotc.config.JavaPlatform class CollectEntryPoints extends MiniPhaseTransform { - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /** perform context-dependant initialization */ override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context) = { entryPoints = collection.immutable.TreeSet.empty[Symbol](new SymbolOrdering()) diff --git a/compiler/src/dotty/tools/dotc/transform/Constructors.scala b/compiler/src/dotty/tools/dotc/transform/Constructors.scala index c1352e0dad2a..969f4f548a07 100644 --- a/compiler/src/dotty/tools/dotc/transform/Constructors.scala +++ b/compiler/src/dotty/tools/dotc/transform/Constructors.scala @@ -39,9 +39,6 @@ class Constructors extends MiniPhaseTransform with IdentityDenotTransformer { th // performed before the rhs undergoes the owner change. This would lead // to more symbols being retained as parameters. Test case in run/capturing.scala. - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /** The private vals that are known to be retained as class fields */ private val retainedPrivateVals = mutable.Set[Symbol]() diff --git a/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala b/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala index c1b155224a24..838286e81181 100644 --- a/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala +++ b/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala @@ -19,9 +19,6 @@ class CrossCastAnd extends MiniPhaseTransform { thisTransform => override def phaseName: String = "crossCast" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformSelect(tree: tpd.Select)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { lazy val qtype = tree.qualifier.tpe.widen diff --git a/compiler/src/dotty/tools/dotc/transform/DropInlined.scala b/compiler/src/dotty/tools/dotc/transform/DropInlined.scala index 83adb99b416e..775663b5c261 100644 --- a/compiler/src/dotty/tools/dotc/transform/DropInlined.scala +++ b/compiler/src/dotty/tools/dotc/transform/DropInlined.scala @@ -10,9 +10,6 @@ class DropInlined extends MiniPhaseTransform { import ast.tpd._ override def phaseName = "dropInlined" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformInlined(tree: Inlined)(implicit ctx: Context, info: TransformerInfo): Tree = Inliner.dropInlined(tree) } diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala index f2f02b286a7d..4202b9f91bb4 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala @@ -42,10 +42,7 @@ class ElimByName extends TransformByNameApply with InfoTransformer { thisTransfo override def phaseName: String = "elimByName" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - - override def runsAfterGroupsOf = Set(classOf[Splitter]) + override def runsAfterGroupsOf = Set(classOf[Splitter]) // I got errors running this phase in an earlier group, but I did not track them down. /** Map `tree` to `tree.apply()` is `ftree` was of ExprType and becomes now a function */ diff --git a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala index 037321b6f8ca..913264081207 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala @@ -23,9 +23,6 @@ class ElimErasedValueType extends MiniPhaseTransform with InfoTransformer { override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure]) - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = sym match { case sym: ClassSymbol if sym is ModuleClass => sym.companionClass match { diff --git a/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala b/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala index 2d984996da17..2ef5c8192bff 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala @@ -17,9 +17,6 @@ class ElimOuterSelect extends MiniPhaseTransform { thisTransform => override def phaseName: String = "elimOuterSelect" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def runsAfterGroupsOf = Set(classOf[ExplicitOuter]) // ExplicitOuter needs to have run to completion before so that all classes // that need an outer accessor have one. diff --git a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala index 3388f99ee7e6..b4b274031b84 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala @@ -30,10 +30,6 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer { thisTransfo override def phaseName = "elimRepeated" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - - override def changesMembers = true // the phase adds vararg bridges def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = diff --git a/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala b/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala index 6d4c9daa79cd..04b574d6fbbd 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala @@ -41,9 +41,6 @@ class ExpandPrivate extends MiniPhaseTransform with IdentityDenotTransformer { t override def phaseName: String = "expandPrivate" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - // This phase moves methods around (in infotransform) so it may need to make other methods public override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[MoveStatics]) diff --git a/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala b/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala index 537d2817a200..76ba7245d6c8 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala @@ -24,9 +24,6 @@ import dotty.tools.dotc.util.Positions.Position class ExpandSAMs extends MiniPhaseTransform { thisTransformer => override def phaseName = "expandSAMs" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - import ast.tpd._ /** Is the SAMType `cls` also a SAM under the rules of the platform? */ diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala index 7e414ba57c89..54e474888654 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala @@ -42,9 +42,6 @@ class ExplicitOuter extends MiniPhaseTransform with InfoTransformer { thisTransf override def phaseName: String = "explicitOuter" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /** List of names of phases that should have finished their processing of all compilation units * before this phase starts */ diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala index b0a94a30a6ff..3592471823ff 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala @@ -28,9 +28,6 @@ class ExplicitSelf extends MiniPhaseTransform { thisTransform => override def phaseName = "explicitSelf" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformIdent(tree: Ident)(implicit ctx: Context, info: TransformerInfo) = tree.tpe match { case tp: ThisType => ctx.debuglog(s"owner = ${ctx.owner}, context = ${ctx}") diff --git a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala index 900a02b6fd33..6924b0582487 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala @@ -42,9 +42,6 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful import tpd._ import ExtensionMethods._ - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /** the following two members override abstract members in Transform */ override def phaseName: String = "extmethods" diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala index 0b068ca6f9e3..35e2d8653d0e 100644 --- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala +++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala @@ -40,9 +40,6 @@ class FirstTransform extends MiniPhaseTransform with InfoTransformer { thisTrans override def phaseName = "firstTransform" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - private[this] var addCompanionPhases: List[NeedsCompanions] = _ override def changesMembers = true // the phase adds companion objects diff --git a/compiler/src/dotty/tools/dotc/transform/FunctionXXLForwarders.scala b/compiler/src/dotty/tools/dotc/transform/FunctionXXLForwarders.scala index e1d9bd54802d..e67247fd8e32 100644 --- a/compiler/src/dotty/tools/dotc/transform/FunctionXXLForwarders.scala +++ b/compiler/src/dotty/tools/dotc/transform/FunctionXXLForwarders.scala @@ -27,9 +27,6 @@ class FunctionXXLForwarders extends MiniPhaseTransform with IdentityDenotTransfo override def phaseName: String = "functionXXLForwarders" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformTemplate(impl: Template)(implicit ctx: Context, info: TransformerInfo): Template = { def forwarderRhs(receiver: Tree, xsTree: Tree): Tree = { diff --git a/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala b/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala index 199ba1644a88..8166e4f35675 100644 --- a/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala +++ b/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala @@ -26,9 +26,6 @@ class FunctionalInterfaces extends MiniPhaseTransform { def phaseName: String = "functionalInterfaces" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - val functionName = "JFunction".toTermName val functionPackage = "scala.compat.java8.".toTermName diff --git a/compiler/src/dotty/tools/dotc/transform/GetClass.scala b/compiler/src/dotty/tools/dotc/transform/GetClass.scala index 221b54f4d638..6a9a5fda2019 100644 --- a/compiler/src/dotty/tools/dotc/transform/GetClass.scala +++ b/compiler/src/dotty/tools/dotc/transform/GetClass.scala @@ -20,9 +20,6 @@ class GetClass extends MiniPhaseTransform { override def phaseName: String = "getClass" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - // getClass transformation should be applied to specialized methods override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure], classOf[FunctionalInterfaces]) diff --git a/compiler/src/dotty/tools/dotc/transform/Getters.scala b/compiler/src/dotty/tools/dotc/transform/Getters.scala index 8ec46222d6bf..31171dfabe5e 100644 --- a/compiler/src/dotty/tools/dotc/transform/Getters.scala +++ b/compiler/src/dotty/tools/dotc/transform/Getters.scala @@ -51,9 +51,6 @@ class Getters extends MiniPhaseTransform with SymTransformer { thisTransform => override def phaseName = "getters" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = { def noGetterNeeded = d.is(NoGetterNeeded) || diff --git a/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala b/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala index d778115138bc..9ef36a7caf56 100644 --- a/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala +++ b/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala @@ -42,9 +42,6 @@ class HoistSuperArgs extends MiniPhaseTransform with IdentityDenotTransformer { def phaseName = "hoistSuperArgs" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def runsAfter = Set(classOf[ByNameClosures]) // By name closures need to be introduced first in order to be hoisted out here. // There's an interaction with by name closures in that the marker diff --git a/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala b/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala index b5a2c4079ec1..b1f384586a0b 100644 --- a/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala +++ b/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala @@ -43,9 +43,6 @@ class InterceptedMethods extends MiniPhaseTransform { override def phaseName: String = "intercepted" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - private[this] var primitiveGetClassMethods: Set[Symbol] = _ var Any_## : Symbol = _ // cached for performance reason diff --git a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala index 34afd87dbd42..f2645c5446cc 100644 --- a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala +++ b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala @@ -74,9 +74,6 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform class LambdaLifter extends TreeTransform { override def phase = thisTransform - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - private type SymSet = TreeSet[Symbol] /** A map storing free variables of functions and classes */ diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala index 47ad3217b70d..9afb3051478c 100644 --- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala +++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala @@ -38,9 +38,6 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer { override def phaseName: String = "LazyVals" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /** List of names of phases that should have finished processing of tree * before this phase starts processing same tree */ override def runsAfter = Set(classOf[Mixin]) diff --git a/compiler/src/dotty/tools/dotc/transform/LiftTry.scala b/compiler/src/dotty/tools/dotc/transform/LiftTry.scala index 4bc60eee8942..278868131c20 100644 --- a/compiler/src/dotty/tools/dotc/transform/LiftTry.scala +++ b/compiler/src/dotty/tools/dotc/transform/LiftTry.scala @@ -32,9 +32,6 @@ class LiftTry extends MiniPhase with IdentityDenotTransformer { thisTransform => class Transform(needLift: Boolean) extends TreeTransform { def phase = thisTransform - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def prepareForApply(tree: Apply)(implicit ctx: Context) = if (tree.fun.symbol.is(Label)) this else liftingTransform diff --git a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala index be4a79674d89..180e48e5f84b 100644 --- a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala +++ b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala @@ -48,9 +48,6 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisTran class Transform extends TreeTransform { def phase = thisTransform - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /** Copy definitions from implementation class to trait itself */ private def augmentScala_2_12_Trait(mixin: ClassSymbol)(implicit ctx: Context): Unit = { def info_2_12(sym: Symbol) = sym.info match { diff --git a/compiler/src/dotty/tools/dotc/transform/Memoize.scala b/compiler/src/dotty/tools/dotc/transform/Memoize.scala index 374919fca5c1..44bb6bd73c88 100644 --- a/compiler/src/dotty/tools/dotc/transform/Memoize.scala +++ b/compiler/src/dotty/tools/dotc/transform/Memoize.scala @@ -37,9 +37,6 @@ import Decorators._ override def phaseName = "memoize" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /* Makes sure that, after getters and constructors gen, there doesn't * exist non-deferred definitions that are not implemented. */ override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = { diff --git a/compiler/src/dotty/tools/dotc/transform/Mixin.scala b/compiler/src/dotty/tools/dotc/transform/Mixin.scala index 753b90cad88b..fc6cc67eba18 100644 --- a/compiler/src/dotty/tools/dotc/transform/Mixin.scala +++ b/compiler/src/dotty/tools/dotc/transform/Mixin.scala @@ -98,9 +98,6 @@ class Mixin extends MiniPhaseTransform with SymTransformer { thisTransform => override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure]) - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def changesMembers = true // the phase adds implementions of mixin accessors override def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation = diff --git a/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala b/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala index 7077a5bc86ba..0942c0b4af11 100644 --- a/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala +++ b/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala @@ -21,9 +21,6 @@ class MoveStatics extends MiniPhaseTransform with SymTransformer { thisTransform import tpd._ override def phaseName = "moveStatic" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation = { if (sym.hasAnnotation(defn.ScalaStaticAnnot) && sym.owner.is(Flags.Module) && sym.owner.companionClass.exists) { sym.owner.asClass.delete(sym.symbol) diff --git a/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala b/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala index 2be7da4deb48..fdee076b452f 100644 --- a/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala +++ b/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala @@ -24,9 +24,6 @@ class NonLocalReturns extends MiniPhaseTransform { thisTransformer => override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[ElimByName]) - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - private def ensureConforms(tree: Tree, pt: Type)(implicit ctx: Context) = if (tree.tpe <:< pt) tree else Erasure.Boxing.adaptToType(tree, pt) diff --git a/compiler/src/dotty/tools/dotc/transform/NormalizeFlags.scala b/compiler/src/dotty/tools/dotc/transform/NormalizeFlags.scala index 4f4790a46315..35a183c84a13 100644 --- a/compiler/src/dotty/tools/dotc/transform/NormalizeFlags.scala +++ b/compiler/src/dotty/tools/dotc/transform/NormalizeFlags.scala @@ -17,9 +17,6 @@ import Flags._, Symbols._ class NormalizeFlags extends MiniPhaseTransform with SymTransformer { thisTransformer => override def phaseName = "normalizeFlags" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - def transformSym(ref: SymDenotation)(implicit ctx: Context) = { var newFlags = ref.flags &~ Local if (newFlags != ref.flags) ref.copySymDenotation(initFlags = newFlags) diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala index 46aab3e7329b..6e8f3141d39b 100644 --- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala +++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala @@ -27,9 +27,6 @@ class PatternMatcher extends MiniPhaseTransform { override def runsAfter = Set(classOf[ElimRepeated]) override def runsAfterGroupsOf = Set(classOf[TailRec]) // tailrec is not capable of reversing the patmat tranformation made for tree - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformMatch(tree: Match)(implicit ctx: Context, info: TransformerInfo): Tree = { val translated = new Translator(tree.tpe, this).translateMatch(tree) diff --git a/compiler/src/dotty/tools/dotc/transform/PhantomArgLift.scala b/compiler/src/dotty/tools/dotc/transform/PhantomArgLift.scala index 02388640bb08..6b823a8ce56f 100644 --- a/compiler/src/dotty/tools/dotc/transform/PhantomArgLift.scala +++ b/compiler/src/dotty/tools/dotc/transform/PhantomArgLift.scala @@ -29,9 +29,6 @@ class PhantomArgLift extends MiniPhaseTransform { override def phaseName: String = "phantomArgLift" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /** Check what the phase achieves, to be called at any point after it is finished. */ override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match { case tree: Apply => diff --git a/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala b/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala index 9ea65eaf5dcf..fec7bd741dab 100644 --- a/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala +++ b/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala @@ -35,9 +35,6 @@ class PrimitiveForwarders extends MiniPhaseTransform with IdentityDenotTransform override def phaseName: String = "primitiveForwarders" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def runsAfter = Set(classOf[ResolveSuper]) override def changesMembers = true // the phase adds primitive forwarders diff --git a/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala b/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala index 65d47bbe189f..8a7b7665a9ec 100644 --- a/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala +++ b/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala @@ -19,9 +19,6 @@ class RenameLifted extends MiniPhaseTransform with SymTransformer { thisTransfor // Not clear why this should run after restoreScopes // override def runsAfterGroupsOf: Set[Class[_ <: Phases.Phase]] = Set(classOf[RestoreScopes]) - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - def transformSym(ref: SymDenotation)(implicit ctx: Context): SymDenotation = if (needsRefresh(ref.symbol)) ref.copySymDenotation(name = refreshedName(ref.symbol)) else ref diff --git a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala index 06677daf8be8..03a8f9678085 100644 --- a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala +++ b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala @@ -50,9 +50,6 @@ class ResolveSuper extends MiniPhaseTransform with IdentityDenotTransformer { th override def phaseName: String = "resolveSuper" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def runsAfter = Set(classOf[ElimByName], // verified empirically, need to figure out what the reason is. classOf[AugmentScala2Traits]) diff --git a/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala b/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala index 6fa73be5e958..8d2b8e25a61a 100644 --- a/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala +++ b/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala @@ -24,9 +24,6 @@ class RestoreScopes extends MiniPhaseTransform with IdentityDenotTransformer { t override def changesMembers = true // the phase affects scopes, applying tree transformations of previous phases - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /* Note: We need to wait until we see a package definition because * DropEmptyConstructors changes template members when analyzing the * enclosing package definitions. So by the time RestoreScopes gets to diff --git a/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala b/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala index f261fa3eda5b..b90c6ed37620 100644 --- a/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala +++ b/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala @@ -20,9 +20,6 @@ class SelectStatic extends MiniPhaseTransform with IdentityDenotTransformer { th override def phaseName: String = "selectStatic" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def transformSelect(tree: tpd.Select)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { val sym = tree.symbol def isStaticMember = diff --git a/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala b/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala index b0845d6e3c53..49ea695300bb 100644 --- a/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala +++ b/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala @@ -24,9 +24,6 @@ class SeqLiterals extends MiniPhaseTransform { override def phaseName = "seqLiterals" override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PatternMatcher]) - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match { case tpd: SeqLiteral => assert(tpd.isInstanceOf[JavaSeqLiteral]) case _ => diff --git a/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala b/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala index 5fc4ef121f82..91301c0cd86e 100644 --- a/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala +++ b/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala @@ -64,9 +64,6 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisTr class Transform extends TreeTransform { def phase = thisTransform - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def prepareForUnit(tree: Tree)(implicit ctx: Context) = new Transform /** A map to cache mapping local methods to their direct counterparts. diff --git a/compiler/src/dotty/tools/dotc/transform/Splitter.scala b/compiler/src/dotty/tools/dotc/transform/Splitter.scala index a553dbd37573..3b6af780c6b9 100644 --- a/compiler/src/dotty/tools/dotc/transform/Splitter.scala +++ b/compiler/src/dotty/tools/dotc/transform/Splitter.scala @@ -13,9 +13,6 @@ class Splitter extends MiniPhaseTransform { thisTransform => override def phaseName: String = "splitter" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /** Distribute arguments among splitted branches */ def distribute(tree: GenericApply[Type], rebuild: (Tree, List[Tree]) => Context => Tree)(implicit ctx: Context) = { def recur(fn: Tree): Tree = fn match { diff --git a/compiler/src/dotty/tools/dotc/transform/TailRec.scala b/compiler/src/dotty/tools/dotc/transform/TailRec.scala index 614dc38e9de3..df48dd157946 100644 --- a/compiler/src/dotty/tools/dotc/transform/TailRec.scala +++ b/compiler/src/dotty/tools/dotc/transform/TailRec.scala @@ -6,6 +6,7 @@ import ast.{TreeTypeMap, tpd} import core._ import Contexts.Context import Decorators._ +import DenotTransformers.IdentityDenotTransformer import Denotations.SingleDenotation import Symbols._ import Types._ @@ -68,9 +69,6 @@ class TailRec extends MiniPhaseTransform with FullParameterization { thisTransfo override def phaseName: String = "tailrec" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - final val labelFlags = Flags.Synthetic | Flags.Label /** Symbols of methods that have @tailrec annotatios inside */ @@ -95,7 +93,6 @@ class TailRec extends MiniPhaseTransform with FullParameterization { thisTransfo else ctx.newSymbol(method, name.toTermName, labelFlags, method.info) } - /** Note: This method should be run atGroupEnd */ override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { val sym = tree.symbol tree match { diff --git a/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala b/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala index 9aa487f1faf6..946722227af9 100644 --- a/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala +++ b/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala @@ -16,9 +16,6 @@ class TransformWildcards extends MiniPhaseTransform with IdentityDenotTransforme override def phaseName = "transformWildcards" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = { tree match { case vDef: ValDef => assert(!tpd.isWildcardArg(vDef.rhs)) diff --git a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala index 420ac3cca9ea..6dedb0119dba 100644 --- a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala +++ b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala @@ -7,6 +7,7 @@ import dotty.tools.dotc.core.Contexts.Context import dotty.tools.dotc.core.DenotTransformers.{InfoTransformer, DenotTransformer} import dotty.tools.dotc.core.Denotations.SingleDenotation import dotty.tools.dotc.core.Phases.Phase +import dotty.tools.dotc.core.Periods._ import dotty.tools.dotc.core.SymDenotations.SymDenotation import dotty.tools.dotc.core.Symbols.Symbol import dotty.tools.dotc.core.Flags.PackageVal @@ -61,10 +62,6 @@ object TreeTransforms { def phase: MiniPhase - /** The phase at which the tree is transformed */ - def treeTransformPhase(implicit ctx: Context, info: TransformerInfo): Phase = - phase.next - val cpy: TypedTreeCopier = cpyBetweenPhases def prepareForIdent(tree: Ident)(implicit ctx: Context) = this @@ -473,6 +470,13 @@ object TreeTransforms { def miniPhases: Array[MiniPhase] + private var myGroupEndId: PhaseId = NoPhaseId + + def groupEndId: PhaseId = { + if (myGroupEndId == NoPhaseId) myGroupEndId = miniPhases.last.id + 1 + myGroupEndId + } + override def run(implicit ctx: Context): Unit = { val curTree = ctx.compilationUnit.tpdTree val newTree = macroTransform(curTree) @@ -496,7 +500,7 @@ object TreeTransforms { var allDone = i < l while (i < l) { val oldTransform = result(i) - val newTransform = mutator(oldTransform, tree, ctx.withPhase(oldTransform.treeTransformPhase(ctx, info))) + val newTransform = mutator(oldTransform, tree, ctx.withPhase(groupEndId)) allDone = allDone && (newTransform eq NoTransform) if (!(oldTransform eq newTransform)) { if (!transformersCopied) result = result.clone() @@ -564,7 +568,7 @@ object TreeTransforms { final private[TreeTransforms] def goIdent(tree: Ident, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformIdent(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformIdent(tree)(ctx.withPhase(groupEndId), info) match { case t: Ident => goIdent(t, info.nx.nxTransIdent(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -575,7 +579,7 @@ object TreeTransforms { final private[TreeTransforms] def goSelect(tree: Select, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformSelect(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformSelect(tree)(ctx.withPhase(groupEndId), info) match { case t: Select => goSelect(t, info.nx.nxTransSelect(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -586,7 +590,7 @@ object TreeTransforms { final private[TreeTransforms] def goThis(tree: This, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformThis(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformThis(tree)(ctx.withPhase(groupEndId), info) match { case t: This => goThis(t, info.nx.nxTransThis(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -597,7 +601,7 @@ object TreeTransforms { final private[TreeTransforms] def goSuper(tree: Super, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformSuper(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformSuper(tree)(ctx.withPhase(groupEndId), info) match { case t: Super => goSuper(t, info.nx.nxTransSuper(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -608,7 +612,7 @@ object TreeTransforms { final private[TreeTransforms] def goApply(tree: Apply, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformApply(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformApply(tree)(ctx.withPhase(groupEndId), info) match { case t: Apply => goApply(t, info.nx.nxTransApply(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -619,7 +623,7 @@ object TreeTransforms { final private[TreeTransforms] def goTypeApply(tree: TypeApply, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformTypeApply(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformTypeApply(tree)(ctx.withPhase(groupEndId), info) match { case t: TypeApply => goTypeApply(t, info.nx.nxTransTypeApply(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -630,7 +634,7 @@ object TreeTransforms { final private[TreeTransforms] def goNew(tree: New, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformNew(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformNew(tree)(ctx.withPhase(groupEndId), info) match { case t: New => goNew(t, info.nx.nxTransNew(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -641,7 +645,7 @@ object TreeTransforms { final private[TreeTransforms] def goTyped(tree: Typed, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformTyped(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformTyped(tree)(ctx.withPhase(groupEndId), info) match { case t: Typed => goTyped(t, info.nx.nxTransTyped(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -652,7 +656,7 @@ object TreeTransforms { final private[TreeTransforms] def goAssign(tree: Assign, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformAssign(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformAssign(tree)(ctx.withPhase(groupEndId), info) match { case t: Assign => goAssign(t, info.nx.nxTransAssign(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -663,7 +667,7 @@ object TreeTransforms { final private[TreeTransforms] def goLiteral(tree: Literal, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformLiteral(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformLiteral(tree)(ctx.withPhase(groupEndId), info) match { case t: Literal => goLiteral(t, info.nx.nxTransLiteral(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -674,7 +678,7 @@ object TreeTransforms { final private[TreeTransforms] def goBlock(tree: Block, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformBlock(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformBlock(tree)(ctx.withPhase(groupEndId), info) match { case t: Block => goBlock(t, info.nx.nxTransBlock(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -685,7 +689,7 @@ object TreeTransforms { final private[TreeTransforms] def goIf(tree: If, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformIf(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformIf(tree)(ctx.withPhase(groupEndId), info) match { case t: If => goIf(t, info.nx.nxTransIf(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -696,7 +700,7 @@ object TreeTransforms { final private[TreeTransforms] def goClosure(tree: Closure, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformClosure(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformClosure(tree)(ctx.withPhase(groupEndId), info) match { case t: Closure => goClosure(t, info.nx.nxTransClosure(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -707,7 +711,7 @@ object TreeTransforms { final private[TreeTransforms] def goMatch(tree: Match, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformMatch(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformMatch(tree)(ctx.withPhase(groupEndId), info) match { case t: Match => goMatch(t, info.nx.nxTransMatch(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -718,7 +722,7 @@ object TreeTransforms { final private[TreeTransforms] def goCaseDef(tree: CaseDef, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformCaseDef(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformCaseDef(tree)(ctx.withPhase(groupEndId), info) match { case t: CaseDef => goCaseDef(t, info.nx.nxTransCaseDef(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -729,7 +733,7 @@ object TreeTransforms { final private[TreeTransforms] def goReturn(tree: Return, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformReturn(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformReturn(tree)(ctx.withPhase(groupEndId), info) match { case t: Return => goReturn(t, info.nx.nxTransReturn(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -740,7 +744,7 @@ object TreeTransforms { final private[TreeTransforms] def goTry(tree: Try, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformTry(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformTry(tree)(ctx.withPhase(groupEndId), info) match { case t: Try => goTry(t, info.nx.nxTransTry(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -751,7 +755,7 @@ object TreeTransforms { final private[TreeTransforms] def goSeqLiteral(tree: SeqLiteral, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformSeqLiteral(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformSeqLiteral(tree)(ctx.withPhase(groupEndId), info) match { case t: SeqLiteral => goSeqLiteral(t, info.nx.nxTransSeqLiteral(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -762,7 +766,7 @@ object TreeTransforms { final private[TreeTransforms] def goInlined(tree: Inlined, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformInlined(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformInlined(tree)(ctx.withPhase(groupEndId), info) match { case t: Inlined => goInlined(t, info.nx.nxTransInlined(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -773,7 +777,7 @@ object TreeTransforms { final private[TreeTransforms] def goTypeTree(tree: TypeTree, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformTypeTree(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformTypeTree(tree)(ctx.withPhase(groupEndId), info) match { case t: TypeTree => goTypeTree(t, info.nx.nxTransTypeTree(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -784,7 +788,7 @@ object TreeTransforms { final private[TreeTransforms] def goBind(tree: Bind, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformBind(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformBind(tree)(ctx.withPhase(groupEndId), info) match { case t: Bind => goBind(t, info.nx.nxTransBind(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -795,7 +799,7 @@ object TreeTransforms { final private[TreeTransforms] def goAlternative(tree: Alternative, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformAlternative(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformAlternative(tree)(ctx.withPhase(groupEndId), info) match { case t: Alternative => goAlternative(t, info.nx.nxTransAlternative(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -806,7 +810,7 @@ object TreeTransforms { final private[TreeTransforms] def goValDef(tree: ValDef, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformValDef(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformValDef(tree)(ctx.withPhase(groupEndId), info) match { case t: ValDef => goValDef(t, info.nx.nxTransValDef(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -817,7 +821,7 @@ object TreeTransforms { final private[TreeTransforms] def goDefDef(tree: DefDef, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformDefDef(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformDefDef(tree)(ctx.withPhase(groupEndId), info) match { case t: DefDef => goDefDef(t, info.nx.nxTransDefDef(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -828,7 +832,7 @@ object TreeTransforms { final private[TreeTransforms] def goUnApply(tree: UnApply, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformUnApply(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformUnApply(tree)(ctx.withPhase(groupEndId), info) match { case t: UnApply => goUnApply(t, info.nx.nxTransUnApply(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -839,7 +843,7 @@ object TreeTransforms { final private[TreeTransforms] def goTypeDef(tree: TypeDef, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformTypeDef(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformTypeDef(tree)(ctx.withPhase(groupEndId), info) match { case t: TypeDef => goTypeDef(t, info.nx.nxTransTypeDef(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -850,7 +854,7 @@ object TreeTransforms { final private[TreeTransforms] def goTemplate(tree: Template, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformTemplate(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformTemplate(tree)(ctx.withPhase(groupEndId), info) match { case t: Template => goTemplate(t, info.nx.nxTransTemplate(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -861,7 +865,7 @@ object TreeTransforms { final private[TreeTransforms] def goPackageDef(tree: PackageDef, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - trans.transformPackageDef(tree)(ctx.withPhase(trans.treeTransformPhase), info) match { + trans.transformPackageDef(tree)(ctx.withPhase(groupEndId), info) match { case t: PackageDef => goPackageDef(t, info.nx.nxTransPackageDef(cur + 1)) case t => transformSingle(t, cur + 1) } @@ -872,7 +876,7 @@ object TreeTransforms { final private[TreeTransforms] def goUnit(tree: Tree, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - val t = trans.transformUnit(tree)(ctx.withPhase(trans.treeTransformPhase), info) + val t = trans.transformUnit(tree)(ctx.withPhase(groupEndId), info) goUnit(t, info.nx.nxTransUnit(cur + 1)) } else tree } @@ -880,7 +884,7 @@ object TreeTransforms { final private[TreeTransforms] def goOther(tree: Tree, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - val t = trans.transformOther(tree)(ctx.withPhase(trans.treeTransformPhase), info) + val t = trans.transformOther(tree)(ctx.withPhase(groupEndId), info) transformSingle(t, cur + 1) } else tree } @@ -1182,7 +1186,7 @@ object TreeTransforms { util.Stats.record("TreeTransform.transform") // if cur > 0 then some of the symbols can be created by already performed transformations // this means that their denotations could not exists in previous period - val pctx = ctx.withPhase(info.transformers(cur).treeTransformPhase(ctx, info)) + val pctx = ctx.withPhase(groupEndId) tree match { //split one big match into 2 smaller ones case tree: NameTree => transformNamed(tree, info, cur)(pctx) @@ -1203,7 +1207,7 @@ object TreeTransforms { final private[TreeTransforms] def goStats(trees: List[Tree], cur: Int)(implicit ctx: Context, info: TransformerInfo): List[Tree] = { if (cur < info.transformers.length) { val trans = info.transformers(cur) - val stats = trans.transformStats(trees)(ctx.withPhase(trans.treeTransformPhase), info) + val stats = trans.transformStats(trees)(ctx.withPhase(groupEndId), info) goStats(stats, info.nx.nxTransStats(cur + 1)) } else trees } diff --git a/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala b/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala index 66c8d01a05ec..44d26e7dd3a4 100644 --- a/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala +++ b/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala @@ -45,9 +45,6 @@ class TryCatchPatterns extends MiniPhaseTransform { def phaseName: String = "tryCatchPatterns" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def runsAfter = Set(classOf[ElimRepeated]) override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match { diff --git a/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala b/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala index 5fc98eeb5847..1582158acaaa 100644 --- a/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala +++ b/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala @@ -20,9 +20,6 @@ class VCElideAllocations extends MiniPhaseTransform with IdentityDenotTransforme override def phaseName: String = "vcElideAllocations" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[ElimErasedValueType]) override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = diff --git a/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala b/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala index e94dd2f8a836..146d30697bae 100644 --- a/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala +++ b/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala @@ -44,9 +44,6 @@ class VCInlineMethods extends MiniPhaseTransform with IdentityDenotTransformer { override def phaseName: String = "vcInlineMethods" - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[ExtensionMethods], classOf[PatternMatcher], classOf[PhantomArgLift]) diff --git a/compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala index 81d3e91c2e98..c78536c3b4fc 100644 --- a/compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala +++ b/compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala @@ -35,9 +35,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer { private[localopt] var SeqFactoryClass: Symbol = null private[localopt] var CommutativePrimitiveOperations: Set[Symbol] = null - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - /** The original intention is to run most optimizations both before and after erasure. * Erasure creates new inefficiencies as well as new optimization opportunities. * diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala index dd368806bcf4..2fe5a0a6f69c 100644 --- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala +++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala @@ -806,9 +806,6 @@ class RefChecks extends MiniPhase { thisTransformer => class Transform(currentLevel: RefChecks.OptLevelInfo = RefChecks.NoLevelInfo) extends TreeTransform { def phase = thisTransformer - override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) = - groupEndPhase - override def prepareForStats(trees: List[Tree])(implicit ctx: Context) = { // println(i"preparing for $trees%; %, owner = ${ctx.owner}") if (ctx.owner.isTerm) new Transform(new LevelInfo(currentLevel.levelAndIndex, trees)) From c302f00da5746d0ec47a413bb92d96d42b97500a Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Sat, 21 Oct 2017 08:36:14 +0200 Subject: [PATCH 18/20] Drop atGroupEnd It's no longer needed, since it's the default now. --- .../dotty/tools/dotc/transform/ExtensionMethods.scala | 4 ++-- compiler/src/dotty/tools/dotc/transform/LazyVals.scala | 10 ++++------ compiler/src/dotty/tools/dotc/transform/TailRec.scala | 2 +- .../src/dotty/tools/dotc/transform/TreeTransform.scala | 6 ------ 4 files changed, 7 insertions(+), 15 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala index 6924b0582487..d1ff4b72c938 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala @@ -175,8 +175,8 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful extensionDefs(staticClass) = newC newC } - store += atGroupEnd(fullyParameterizedDef(extensionMeth, tree)(_)) - cpy.DefDef(tree)(rhs = atGroupEnd(forwarder(extensionMeth, tree)(_))) + store += fullyParameterizedDef(extensionMeth, tree) + cpy.DefDef(tree)(rhs = forwarder(extensionMeth, tree)) } else tree } } diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala index 9afb3051478c..94b046d317df 100644 --- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala +++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala @@ -166,12 +166,10 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer { // backend requires field usage to be after field definition // need to bring containers to start of method val (holders, stats) = - atGroupEnd { implicit ctx: Context => - trees.partition { - _.symbol.flags.&~(Flags.Touched) == containerFlags - // Filtering out Flags.Touched is not required currently, as there are no LazyTypes involved here - // but just to be more safe - } + trees.partition { + _.symbol.flags.&~(Flags.Touched) == containerFlags + // Filtering out Flags.Touched is not required currently, as there are no LazyTypes involved here + // but just to be more safe } holders:::stats } diff --git a/compiler/src/dotty/tools/dotc/transform/TailRec.scala b/compiler/src/dotty/tools/dotc/transform/TailRec.scala index df48dd157946..8ab4e94c93d8 100644 --- a/compiler/src/dotty/tools/dotc/transform/TailRec.scala +++ b/compiler/src/dotty/tools/dotc/transform/TailRec.scala @@ -115,7 +115,7 @@ class TailRec extends MiniPhaseTransform with FullParameterization { thisTransfo // now this speculatively transforms tree and throws away result in many cases val rhsSemiTransformed = { val transformer = new TailRecElimination(origMeth, dd.tparams, owner, thisTpe, mandatory, label, abstractOverClass = defIsTopLevel) - val rhs = atGroupEnd(implicit ctx => transformer.transform(dd.rhs)) + val rhs = transformer.transform(dd.rhs) rewrote = transformer.rewrote rhs } diff --git a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala index 6dedb0119dba..76fcc0927290 100644 --- a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala +++ b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala @@ -137,12 +137,6 @@ object TreeTransforms { /** Transform single node using all transforms following the current one in this group */ def transformFollowing(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = info.group.transformSingle(tree, phase.idx + 1) - - def atGroupEnd[T](action : Context => T)(implicit ctx: Context, info: TransformerInfo) = - action(ctx.withPhase(groupEndPhase)) - - def groupEndPhase(implicit ctx: Context, info: TransformerInfo) = - info.transformers(info.transformers.length - 1).phase.next } /** A phase that defines a TreeTransform to be used in a group */ From 3a0184cdc844dc197939fdfb197cb529ec9c0894 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Sat, 21 Oct 2017 08:39:18 +0200 Subject: [PATCH 19/20] Re-instantiate test Got deleted by accident before. --- tests/pickling/i3149.scala | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 tests/pickling/i3149.scala diff --git a/tests/pickling/i3149.scala b/tests/pickling/i3149.scala new file mode 100644 index 000000000000..c582590822ef --- /dev/null +++ b/tests/pickling/i3149.scala @@ -0,0 +1,7 @@ +sealed class Foo + +class Test { + def f = { + class Bar extends Foo + } +} From fdf17d0504700e08fefa2d4bda1fbffbba3eefd2 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Sun, 22 Oct 2017 13:16:16 +0200 Subject: [PATCH 20/20] Use cpyBetweenPhases as the copier for TreeTransformers TreeTransform used cpyBetweenPhases, but TreeTransformer did not. This does not seem sensical. Most likely this was overlooked. TreeTransform/TreeTransformer is too similar, one gets confused easily what is what. --- compiler/src/dotty/tools/dotc/transform/TreeTransform.scala | 2 ++ 1 file changed, 2 insertions(+) diff --git a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala index 76fcc0927290..d3fd77f1403c 100644 --- a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala +++ b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala @@ -471,6 +471,8 @@ object TreeTransforms { myGroupEndId } + val cpy: TypedTreeCopier = cpyBetweenPhases + override def run(implicit ctx: Context): Unit = { val curTree = ctx.compilationUnit.tpdTree val newTree = macroTransform(curTree)