Drop InSuperCall flag

and special handling involved in it. Require to be after phase
HoistInSuperCall instead.

Author: odersky

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

@@ -372,9 +372,6 @@ object Flags {
   /** Symbol always defines a fresh named type */
   final val Fresh = commonFlag(45, "<fresh>")
 
-  /** Symbol is defined in a super call */
-  final val InSuperCall = commonFlag(46, "<in supercall>")
-
   /** Denotation is in train of being loaded and completed, used to catch cyclic dependencies */
   final val Touched = commonFlag(48, "<touched>")
 
@@ -451,7 +448,7 @@ object Flags {
   /** Flags guaranteed to be set upon symbol creation */
   final val FromStartFlags =
     Module | Package | Deferred | MethodOrHKCommon | Param | ParamAccessor |
-    Scala2ExistentialCommon | Mutable.toCommonFlags | InSuperCall | Touched | JavaStatic |
+    Scala2ExistentialCommon | Mutable.toCommonFlags | Touched | JavaStatic |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessorOrBaseTypeArg |
     Fresh | Frozen | Erroneous | ImplicitCommon | Permanent | Synthetic |
     SuperAccessorOrScala2x | Inline
@@ -511,8 +508,7 @@ object Flags {
     Accessor | AbsOverride | Stable | Captured | Synchronized
 
   /** Flags that can apply to a module class */
-  final val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags |
-    InSuperCall | ImplClass
+  final val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | ImplClass
 
   /** Packages and package classes always have these flags set */
   final val PackageCreationFlags =

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

@@ -851,7 +851,7 @@ object SymDenotations {
 
     /** The class containing this denotation.
      *  If this denotation is already a class, return itself
-     *  Definitions flagged with InSuperCall are treated specially.
+     *  Definitions flagged with JavaStatic are treated specially.
      *  Their enclosing class is not the lexically enclosing class,
      *  but in turn the enclosing class of the latter. This reflects
      *  the context created by `Context#superCallContext`, `Context#thisCallArgContext`
@@ -862,7 +862,7 @@ object SymDenotations {
      */
     final def enclosingClass(implicit ctx: Context): Symbol = {
       def enclClass(sym: Symbol, skip: Boolean): Symbol = {
-        def newSkip = sym.is(InSuperCall) || sym.is(JavaStaticTerm)
+        def newSkip = sym.is(JavaStaticTerm)
         if (!sym.exists)
           NoSymbol
         else if (sym.isClass)

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

@@ -186,7 +186,6 @@ Standard-Section: "ASTs" TopLevelStat*
                   CONTRAVARIANT             // type param marked “-”
                   SCALA2X                           // Imported from Scala2.x
                   DEFAULTparameterized  // Method with default params
-                  INSUPERCALL           // defined in the argument of a constructor supercall
                   STABLE                // Method that is assumed to be stable
                   Annotation
   Annotation    = ANNOTATION     Length tycon_Type fullAnnotation_Term
@@ -278,8 +277,7 @@ object TastyFormat {
   final val CONTRAVARIANT = 28
   final val SCALA2X = 29
   final val DEFAULTparameterized = 30
-  final val INSUPERCALL = 31
-  final val STABLE = 32
+  final val STABLE = 31
 
   final val SHARED = 64
   final val TERMREFdirect = 65
@@ -403,7 +401,6 @@ object TastyFormat {
        | CONTRAVARIANT
        | SCALA2X
        | DEFAULTparameterized
-       | INSUPERCALL
        | STABLE
        | ANNOTATION
        | PRIVATEqualified
@@ -469,7 +466,6 @@ object TastyFormat {
     case CONTRAVARIANT => "CONTRAVARIANT"
     case SCALA2X => "SCALA2X"
     case DEFAULTparameterized => "DEFAULTparameterized"
-    case INSUPERCALL => "INSUPERCALL"
     case STABLE => "STABLE"
 
     case SHARED => "SHARED"

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

@@ -577,7 +577,6 @@ class TreePickler(pickler: TastyPickler) {
     if (flags is Synthetic) writeByte(SYNTHETIC)
     if (flags is Artifact) writeByte(ARTIFACT)
     if (flags is Scala2x) writeByte(SCALA2X)
-    if (flags is InSuperCall) writeByte(INSUPERCALL)
     if (sym.isTerm) {
       if (flags is Implicit) writeByte(IMPLICIT)
       if ((flags is Lazy) && !(sym is Module)) writeByte(LAZY)

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

@@ -510,7 +510,6 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
           case CONTRAVARIANT => addFlag(Contravariant)
           case SCALA2X => addFlag(Scala2x)
           case DEFAULTparameterized => addFlag(DefaultParameterized)
-          case INSUPERCALL => addFlag(InSuperCall)
           case STABLE => addFlag(Stable)
           case PRIVATEqualified =>
             readByte()

compiler/src/dotty/tools/dotc/transform/Constructors.scala

@@ -30,8 +30,7 @@ class Constructors extends MiniPhaseTransform with IdentityDenotTransformer { th
   import tpd._
 
   override def phaseName: String = "constructors"
-  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Memoize])
-
+  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Memoize], classOf[HoistSuperArgs])
 
   // Collect all private parameter accessors and value definitions that need
   // to be retained. There are several reasons why a parameter accessor or
@@ -103,7 +102,7 @@ class Constructors extends MiniPhaseTransform with IdentityDenotTransformer { th
    *                outer link, so no parameter accessors need to be rewired to parameters
    */
   private def noDirectRefsFrom(tree: Tree)(implicit ctx: Context) =
-    tree.isDef && tree.symbol.isClass && !tree.symbol.is(InSuperCall)
+    tree.isDef && tree.symbol.isClass
 
   /** Class members that can be eliminated if referenced only from their own
    *  constructor.

compiler/src/dotty/tools/dotc/transform/ElimByName.scala

@@ -58,6 +58,7 @@ class ElimByName extends MiniPhaseTransform with InfoTransformer { thisTransform
 
   override def phaseName: String = "elimByName"
 
+  override def runsAfter = Set(classOf[HoistSuperCalls])
   override def runsAfterGroupsOf = Set(classOf[Splitter])
     // assumes idents and selects have symbols; interferes with splitter distribution
     // that's why it's "after group".
@@ -78,9 +79,8 @@ class ElimByName extends MiniPhaseTransform with InfoTransformer { thisTransform
           if qual.tpe.derivesFrom(defn.FunctionClass(0)) && isPureExpr(qual) =>
             qual
           case _ =>
-            val inSuper = if (ctx.mode.is(Mode.InSuperCall)) InSuperCall else EmptyFlags
             val meth = ctx.newSymbol(
-                ctx.owner, nme.ANON_FUN, Synthetic | Method | inSuper, MethodType(Nil, Nil, argType))
+                ctx.owner, nme.ANON_FUN, Synthetic | Method, MethodType(Nil, Nil, argType))
             Closure(meth, _ =>
               atGroupEnd { implicit ctx: Context =>
                 arg.changeOwner(ctx.owner, meth)

compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -46,7 +46,7 @@ class ExplicitOuter extends MiniPhaseTransform with InfoTransformer { thisTransf
   /** List of names of phases that should have finished their processing of all compilation units
     * before this phase starts
     */
-  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PatternMatcher])
+  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PatternMatcher], classOf[HoistSuperArgs])
 
   /** Add outer accessors if a class always needs an outer pointer */
   override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context) = tp match {

compiler/src/dotty/tools/dotc/transform/LambdaLift.scala

@@ -66,7 +66,7 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
 
   override def relaxedTyping = true
 
-  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Constructors])
+  override def runsAfter: 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
     // converted to parameters in super calls. Without this it is very hard to get
@@ -146,14 +146,10 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
       if (sym.maybeOwner.isTerm &&
         owner.isProperlyContainedIn(liftedOwner(sym)) &&
         owner != sym) {
-        if (sym.is(InSuperCall) && owner.isProperlyContainedIn(sym.enclosingClass))
-          narrowLiftedOwner(sym, sym.enclosingClass)
-        else {
           ctx.log(i"narrow lifted $sym to $owner")
           changedLiftedOwner = true
           liftedOwner(sym) = owner
         }
-      }
 
     /** Mark symbol `sym` as being free in `enclosure`, unless `sym` is defined
      *  in `enclosure` or there is an intermediate class properly containing `enclosure`
@@ -387,7 +383,7 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
         local.copySymDenotation(
           owner = newOwner,
           name = newName(local),
-          initFlags = local.flags &~ (InSuperCall | Module) | Private | maybeStatic,
+          initFlags = local.flags &~ Module | Private | maybeStatic,
             // drop Module because class is no longer a singleton in the lifted context.
           info = liftedInfo(local)).installAfter(thisTransform)
       }

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -278,14 +278,12 @@ class Namer { typer: Typer =>
         else name
     }
 
-    val inSuperCall = if (ctx.mode is Mode.InSuperCall) InSuperCall else EmptyFlags
-
     tree match {
       case tree: TypeDef if tree.isClassDef =>
         val name = checkNoConflict(tree.name.encode).toTypeName
         val flags = checkFlags(tree.mods.flags &~ Implicit)
         val cls = recordSym(ctx.newClassSymbol(
-          ctx.owner, name, flags | inSuperCall,
+          ctx.owner, name, flags,
           cls => adjustIfModule(new ClassCompleter(cls, tree)(ctx), tree),
           privateWithinClass(tree.mods), tree.namePos, ctx.source.file), tree)
         cls.completer.asInstanceOf[ClassCompleter].init()
@@ -296,8 +294,6 @@ class Namer { typer: Typer =>
         val isDeferred = lacksDefinition(tree)
         val deferred = if (isDeferred) Deferred else EmptyFlags
         val method = if (tree.isInstanceOf[DefDef]) Method else EmptyFlags
-        val inSuperCall1 = if (tree.mods is ParamOrAccessor) EmptyFlags else inSuperCall
-          // suppress inSuperCall for constructor parameters
         val higherKinded = tree match {
           case TypeDef(_, LambdaTypeTree(_, _)) if isDeferred => HigherKinded
           case _ => EmptyFlags
@@ -320,7 +316,7 @@ class Namer { typer: Typer =>
         }
 
         recordSym(ctx.newSymbol(
-          ctx.owner, name, flags | deferred | method | higherKinded | inSuperCall1,
+          ctx.owner, name, flags | deferred | method | higherKinded,
           adjustIfModule(completer, tree),
           privateWithinClass(tree.mods), tree.namePos), tree)
       case tree: Import =>