Produce PureInterface flag together with NoInits flag

The previous stale symbol was discovered because NormalizeFlags looks
at all declarations of a MoInits trait in the SymTransformer. I.e it does
this for all no-init traits, whether loaded from a classfile or currently
compiled. This is wasteful because it forces too many definitions.

The new scheme drops the scan in favor of producing PureInterface
together with NoInits. PureInterface is already read as a flag from
Java snd Scala2 classfiles. For source and Tasty it is now generated
as members are indexed.

Author: odersky

src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -8,6 +8,7 @@ import Names._, StdNames._, NameOps._, Decorators._, Symbols._
 import util.HashSet
 
 trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
+  import TreeInfo._
 
   // Note: the <: Type constraint looks necessary (and is needed to make the file compile in dotc).
   // But Scalac accepts the program happily without it. Need to find out why.
@@ -26,10 +27,12 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
 
   /** Does tree contain an initialization part when seen as a member of a class or trait?
    */
-  def isNoInitMember(tree: Tree): Boolean = unsplice(tree) match {
-    case EmptyTree | Import(_, _) | TypeDef(_, _) | DefDef(_, _, _, _, _) => true
-    case tree: ValDef => tree.unforcedRhs == EmptyTree
-    case _ => false
+  def defKind(tree: Tree): DefKind = unsplice(tree) match {
+    case EmptyTree | _: Import => InterfaceDef
+    case tree: TypeDef => if (tree.isClassDef) NoInitDef else InterfaceDef
+    case tree: DefDef => if (tree.unforcedRhs == EmptyTree) InterfaceDef else NoInitDef
+    case tree: ValDef => if (tree.unforcedRhs == EmptyTree) InterfaceDef else GeneralDef
+    case _ => GeneralDef
   }
 
   def isOpAssign(tree: Tree) = unsplice(tree) match {
@@ -272,6 +275,7 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
 }
 
 trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
+  import TreeInfo._
 
   /** The purity level of this statement.
    *  @return   pure        if statement has no side effects
@@ -510,15 +514,27 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       case nil =>
         Nil
     }
+}
+
+object TreeInfo {
 
-  private class PurityLevel(val x: Int) {
+  class PurityLevel(val x: Int) extends AnyVal {
     def >= (that: PurityLevel) = x >= that.x
     def min(that: PurityLevel) = new PurityLevel(x min that.x)
   }
 
-  private val Pure = new PurityLevel(2)
-  private val Idempotent = new PurityLevel(1)
-  private val Impure = new PurityLevel(0)
+  val Pure = new PurityLevel(2)
+  val Idempotent = new PurityLevel(1)
+  val Impure = new PurityLevel(0)
+
+  case class DefKind(val x: Int) extends AnyVal {
+    def >= (that: DefKind) = x >= that.x
+    def min(that: DefKind) = new DefKind(x min that.x)
+  }
+
+  val InterfaceDef = new DefKind(2)
+  val NoInitDef = new DefKind(1)
+  val GeneralDef = new DefKind(0)
 }
 
   /** a Match(Typed(_, tpt), _) must be translated into a switch if isSwitchAnnotation(tpt.tpe)

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

@@ -115,6 +115,12 @@ object SymDenotations {
     /** Unset given flags(s) of this denotation */
     final def resetFlag(flags: FlagSet): Unit = { myFlags &~= flags }
 
+    final def setFlagsFromDefKind(kind: TreeInfo.DefKind): Unit =
+      if (kind >= TreeInfo.NoInitDef) {
+        setFlag(NoInits)
+        if (kind == TreeInfo.InterfaceDef && myFlags.is(Trait)) setFlag(PureInterface)
+      }
+
     /** Has this denotation one of the flags in `fs` set? */
     final def is(fs: FlagSet)(implicit ctx: Context) = {
       (if (fs <= FromStartFlags) myFlags else flags) is fs

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

@@ -6,7 +6,8 @@ package tasty
 import Contexts._, Symbols._, Types._, Scopes._, SymDenotations._, Names._, NameOps._
 import StdNames._, Denotations._, Flags._, Constants._, Annotations._
 import util.Positions._
-import dotty.tools.dotc.ast.{tpd, Trees, untpd}
+import ast.{tpd, Trees, untpd}
+import ast.TreeInfo._
 import Trees._
 import Decorators._
 import TastyUnpickler._, TastyBuffer._, PositionPickler._
@@ -352,7 +353,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
     /** Create symbol of definition node and enter in symAtAddr map
      *  @return  true iff the definition does not contain initialization code
      */
-    def createSymbol()(implicit ctx: Context): Boolean = {
+    def createSymbol()(implicit ctx: Context): DefKind = {
       val start = currentAddr
       val tag = readByte()
       val end = readEnd()
@@ -408,7 +409,10 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         sym.completer.withDecls(newScope)
         forkAt(templateStart).indexTemplateParams()(localContext(sym))
       }
-      tag != VALDEF || rhsIsEmpty
+      if (isClass) NoInitDef
+      else if (sym.isType || sym.isConstructor || flags.is(Deferred)) InterfaceDef
+      else if (tag == VALDEF) GeneralDef
+      else NoInitDef
     }
 
     /** Read modifier list into triplet of flags, annotations and a privateWithin
@@ -474,23 +478,23 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
      *  current address and `end`.
      *  @return  true iff none of the statements contains initialization code
      */
-    def indexStats(end: Addr)(implicit ctx: Context): Boolean = {
-      val noInitss =
+    def indexStats(end: Addr)(implicit ctx: Context): DefKind = {
+      val defKinds =
         until(end) {
           nextByte match {
             case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM =>
               createSymbol()
             case IMPORT =>
               skipTree()
-              true
+              InterfaceDef
             case PACKAGE =>
               processPackage { (pid, end) => implicit ctx => indexStats(end) }
             case _ =>
               skipTree()
-              false
+              GeneralDef
           }
         }
-      noInitss.forall(_ == true)
+      (InterfaceDef /: defKinds)(_ min _)
     }
 
     /** Process package with given operation `op`. The operation takes as arguments
@@ -631,8 +635,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         }
         else EmptyValDef
       setClsInfo(parentRefs, if (self.isEmpty) NoType else self.tpt.tpe)
-      val noInits = fork.indexStats(end)
-      if (noInits) cls.setFlag(NoInits)
+      cls.setFlagsFromDefKind(fork.indexStats(end))
       val constr = readIndexedDef().asInstanceOf[DefDef]
 
       def mergeTypeParamsAndAliases(tparams: List[TypeDef], stats: List[Tree]): (List[Tree], List[Tree]) =

src/dotty/tools/dotc/transform/NormalizeFlags.scala

@@ -19,12 +19,7 @@ class NormalizeFlags extends MiniPhaseTransform with SymTransformer { thisTransf
 
   def transformSym(ref: SymDenotation)(implicit ctx: Context) = {
     var newFlags = ref.flags &~ Local
-    if (ref.is(NoInitsTrait) && ref.info.decls.forall(isPureInterfaceMember))
-      newFlags |= PureInterface
     if (newFlags != ref.flags) ref.copySymDenotation(initFlags = newFlags)
     else ref
   }
-
-  private def isPureInterfaceMember(sym: Symbol)(implicit ctx: Context) =
-    if (sym.isTerm) sym.is(Deferred) else !sym.isClass
 }

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

@@ -563,7 +563,8 @@ class Namer { typer: Typer =>
 
       index(rest)(inClassContext(selfInfo))
       denot.info = ClassInfo(cls.owner.thisType, cls, parentRefs, decls, selfInfo)
-      if (impl.body forall isNoInitMember) cls.setFlag(NoInits)
+      cls.setFlagsFromDefKind(
+        (TreeInfo.InterfaceDef /: impl.body)((kind, stat) => kind min defKind(stat)))
     }
   }