Take parents of class into account when determining NoInits flags

We declare a class (not a trait) impure if it passes arguments to its parents.
This is a very conservative estimate. It's hard to do better, though, since
parent expressions are not always typed when we need to decide class purity.
So we cannot use `isPureExpr` on argument expressions to find out more.

Author: odersky

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

@@ -241,7 +241,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   }
 
   /**  The largest subset of {NoInits, PureInterface} that a
-   *   trait enclosing this statement can have as flags.
+   *   trait or class enclosing this statement can have as flags.
    */
   def defKind(tree: Tree)(implicit ctx: Context): FlagSet = unsplice(tree) match {
     case EmptyTree | _: Import => NoInitsInterface
@@ -254,6 +254,21 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case _ => EmptyFlags
   }
 
+  /**  The largest subset of {NoInits, PureInterface} that a
+   *   trait or class with these parents can have as flags.
+   */
+  def parentsKind(parents: List[Tree])(implicit ctx: Context): FlagSet = parents match {
+    case Nil => NoInitsInterface
+    case Apply(_, _ :: _) :: _ => EmptyFlags
+    case _ :: parents1 => parentsKind(parents1)
+  }
+
+  /**  The largest subset of {NoInits, PureInterface} that a
+   *   trait or class with this body can have as flags.
+   */
+  def bodyKind(body: List[Tree])(implicit ctx: Context): FlagSet =
+    (NoInitsInterface /: body)((fs, stat) => fs & defKind(stat))
+
   /** Checks whether predicate `p` is true for all result parts of this expression,
    *  where we zoom into Ifs, Matches, and Blocks.
    */

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

@@ -167,11 +167,14 @@ object SymDenotations {
     /** Unset given flags(s) of this denotation */
     final def resetFlag(flags: FlagSet): Unit = { myFlags &~= flags }
 
-    /** Set applicable flags from `flags` which is a subset of {NoInits, PureInterface} */
-    final def setNoInitsFlags(flags: FlagSet): Unit = {
-      val mask = if (myFlags.is(Trait)) NoInitsInterface else NoInits
-      setFlag(flags & mask)
-    }
+    /** Set applicable flags in {NoInits, PureInterface}
+     *  @param  parentFlags  The flags that match the class or trait's parents
+     *  @param  bodyFlags    The flags that match the class or trait's body
+     */
+    final def setNoInitsFlags(parentFlags: FlagSet, bodyFlags: FlagSet): Unit =
+      setFlag(
+        if (myFlags.is(Trait)) NoInitsInterface & bodyFlags // no parents are initialized from a trait
+        else NoInits & bodyFlags & parentFlags)
 
     private def isCurrent(fs: FlagSet) =
       fs <= (

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

@@ -851,7 +851,7 @@ class TreeUnpickler(reader: TastyReader,
         else EmptyValDef
       cls.info = ClassInfo(cls.owner.thisType, cls, parentTypes, cls.unforcedDecls,
         if (self.isEmpty) NoType else self.tpt.tpe)
-      cls.setNoInitsFlags(fork.indexStats(end))
+      cls.setNoInitsFlags(parentsKind(parents), fork.indexStats(end))
       val constr = readIndexedDef().asInstanceOf[DefDef]
       val mappedParents = parents.map(_.changeOwner(localDummy, constr.symbol))
 

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

@@ -991,7 +991,7 @@ class Namer { typer: Typer =>
       if (isDerivedValueClass(cls)) cls.setFlag(Final)
       cls.info = avoidPrivateLeaks(cls, cls.pos)
       cls.baseClasses.foreach(_.invalidateBaseTypeCache()) // we might have looked before and found nothing
-      cls.setNoInitsFlags((NoInitsInterface /: impl.body) ((fs, stat) => fs & untpd.defKind(stat)))
+      cls.setNoInitsFlags(parentsKind(parents), bodyKind(rest))
       if (cls.isNoInitsClass) cls.primaryConstructor.setFlag(Stable)
     }
   }