Refactor check and implement promotion

- Make summary a proper class
- Rename isInternal to hasSource
- Enable hijacking check

- Refactor: remove useless parameter
- Check promotion of potentials
- Cache safely promoted potential

- Fix test case tests/init/neg/hybrid2.scala
- Split effect check into multiple methods
- Refactor ignored methods handling
  Ignore constructor call on Any, Object and AnyVal

- Add promotion tests
- Fix missing return
- Member promotion result override outer promotion result

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/init/Checker.scala

@@ -47,7 +47,7 @@ class Checker extends MiniPhase {
     // A concrete class may not be instantiated if the self type is not satisfied
     if (instantiable) {
       implicit val state: Checking.State = Checking.State(
-        visited = Set.empty,
+        checked = Set.empty,
         path = Vector.empty,
         thisClass = cls,
         fieldsInited = mutable.Set.empty,

compiler/src/dotty/tools/dotc/transform/init/Checking.scala

@@ -18,19 +18,20 @@ import scala.collection.mutable
 
 import Effects._, Potentials._, Summary._
 
-implicit def theCtx(implicit env: Env): Context = env.ctx
+given theCtx(using Env): Context = summon[Env].ctx
 
 case class Env(ctx: Context) {
   private implicit def self: Env = this
 
-  // Methods that should be ignored in the checking
-  lazy val ignoredMethods: Set[Symbol] = Set(
-    defn.Any_getClass,
-    defn.Any_isInstanceOf,
-    defn.Object_eq,
-    defn.Object_ne,
-    defn.Object_synchronized
-  )
+  /** Can the method call be ignored? */
+  def canIgnoreMethod(symbol: Symbol): Boolean =
+    !symbol.exists || // possible with outer selection, tests/init/crash/i1990b.scala
+    canIgnoreClass(symbol.owner)
+
+  def canIgnoreClass(cls: Symbol): Boolean =
+    cls == defn.AnyClass ||
+    cls == defn.AnyValClass ||
+    cls == defn.ObjectClass
 
   def withCtx(newCtx: Context): Env = this.copy(ctx = newCtx)
 

compiler/src/dotty/tools/dotc/transform/init/Env.scala

@@ -12,8 +12,8 @@ import Types._, Symbols._, Contexts._
 import Effects._, Potentials._
 
 object Errors {
-  type Errors = Set[Error]
-  val empty: Errors = Set.empty
+  type Errors = List[Error]
+  val empty: Errors = Nil
 
   def show(errs: Errors)(using Context): String =
     errs.map(_.show).mkString(", ")
@@ -26,7 +26,7 @@ object Errors {
     def issue(using Context): Unit =
       report.warning(show + stacktrace, source.srcPos)
 
-    def toErrors: Errors = Set(this)
+    def toErrors: Errors = this :: Nil
 
     def stacktrace(using Context): String = if (trace.isEmpty) "" else " Calling trace:\n" + {
       var indentCount = 0
@@ -55,15 +55,15 @@ object Errors {
      */
     def flatten: Errors = this match {
       case unsafe: UnsafePromotion => unsafe.errors.flatMap(_.flatten)
-      case _ => Set(this)
+      case _ => this :: Nil
     }
   }
 
   /** Access non-initialized field */
   case class AccessNonInit(field: Symbol, trace: Vector[Tree]) extends Error {
     def source: Tree = trace.last
     def show(using Context): String =
-      "Access non-initialized field " + field.name.show + "."
+      "Access non-initialized " + field.show + "."
 
     override def issue(using Context): Unit =
       report.warning(show + stacktrace, field.srcPos)

compiler/src/dotty/tools/dotc/transform/init/Errors.scala

@@ -32,25 +32,37 @@ object Potentials {
     def source: Tree
   }
 
-  /** The object pointed by `this` */
-  case class ThisRef()(val source: Tree) extends Potential {
-    def show(using Context): String = "this"
-
+  sealed trait Refinable extends Potential {
     /** Effects of a method call or a lazy val access
+     *
+     *  The method performs prefix substitution
      */
     def effectsOf(sym: Symbol)(implicit env: Env): Effects = trace("effects of " + sym.show, init, r => Effects.show(r.asInstanceOf)) {
       val cls = sym.owner.asClass
-      env.summaryOf(cls).effectsOf(sym)
+      val effs = env.summaryOf(cls).effectsOf(sym)
+      this match
+      case _: ThisRef => effs
+      case _ =>  Effects.asSeenFrom(effs, this)
     }
 
     /** Potentials of a field, a method call or a lazy val access
+     *
+     *  The method performs prefix substitution
      */
     def potentialsOf(sym: Symbol)(implicit env: Env): Potentials = trace("potentials of " + sym.show, init, r => Potentials.show(r.asInstanceOf)) {
       val cls = sym.owner.asClass
-      env.summaryOf(cls).potentialsOf(sym)
+      val pots = env.summaryOf(cls).potentialsOf(sym)
+      this match
+      case _: ThisRef => pots
+      case _ => Potentials.asSeenFrom(pots, this)
     }
   }
 
+  /** The object pointed by `this` */
+  case class ThisRef()(val source: Tree) extends Refinable {
+    def show(using Context): String = "this"
+  }
+
   /** The object pointed by `C.super.this`, mainly used for override resolution */
   case class SuperRef(pot: Potential, supercls: ClassSymbol)(val source: Tree) extends Potential {
     override def size: Int = pot.size
@@ -64,30 +76,10 @@ object Potentials {
    *  @param classSymbol  The concrete class of the object
    *  @param outer        The potential for `this` of the enclosing class
    */
-  case class Warm(classSymbol: ClassSymbol, outer: Potential)(val source: Tree) extends Potential {
+  case class Warm(classSymbol: ClassSymbol, outer: Potential)(val source: Tree) extends Refinable {
     override def level: Int = 1 + outer.level
     def show(using Context): String = "Warm[" + classSymbol.show + ", outer = " + outer.show + "]"
 
-    /** Effects of a method call or a lazy val access
-     *
-     *  The method performs prefix substitution
-     */
-    def effectsOf(sym: Symbol)(implicit env: Env): Effects = trace("effects of " + sym.show, init, r => Effects.show(r.asInstanceOf)) {
-      val cls = sym.owner.asClass
-      val effs = env.summaryOf(cls).effectsOf(sym)
-      Effects.asSeenFrom(effs, this)
-    }
-
-    /** Potentials of a field, a method call or a lazy val access
-     *
-     *  The method performs prefix substitution
-     */
-    def potentialsOf(sym: Symbol)(implicit env: Env): Potentials = trace("potentials of " + sym.show, init, r => Potentials.show(r.asInstanceOf)) {
-      val cls = sym.owner.asClass
-      val pots = env.summaryOf(cls).potentialsOf(sym)
-      Potentials.asSeenFrom(pots, this)
-    }
-
     def resolveOuter(cls: ClassSymbol)(implicit env: Env): Potentials =
       env.resolveOuter(this, cls)
   }
@@ -117,7 +109,7 @@ object Potentials {
   case class Outer(pot: Potential, classSymbol: ClassSymbol)(val source: Tree) extends Potential {
     // be lenient with size of outer selection, no worry for non-termination
     override def size: Int = pot.size
-    override def level: Int = pot.size
+    override def level: Int = pot.level
     def show(using Context): String = pot.show + ".outer[" + classSymbol.show + "]"
   }
 
@@ -126,7 +118,7 @@ object Potentials {
     assert(field != NoSymbol)
 
     override def size: Int = potential.size + 1
-    override def level: Int = potential.size
+    override def level: Int = potential.level
     def show(using Context): String = potential.show + "." + field.name.show
   }
 
@@ -135,7 +127,7 @@ object Potentials {
     assert(method != NoSymbol)
 
     override def size: Int = potential.size + 1
-    override def level: Int = potential.size
+    override def level: Int = potential.level
     def show(using Context): String = potential.show + "." + method.name.show
   }
 
@@ -163,20 +155,20 @@ object Potentials {
   extension (pot: Potential) def toPots: Potentials = Potentials.empty + pot
 
   extension (ps: Potentials) def select (symbol: Symbol, source: Tree)(using Context): Summary =
-    ps.foldLeft(Summary.empty) { case ((pots, effs), pot) =>
+    ps.foldLeft(Summary.empty) { case (Summary(pots, effs), pot) =>
       // max potential length
       // TODO: it can be specified on a project basis via compiler options
       if (pot.size > 2)
-        (pots, effs + Promote(pot)(source))
+        summary + Promote(pot)(pot.source)
       else if (symbol.isConstructor)
-        (pots + pot, effs + MethodCall(pot, symbol)(source))
+        Summary(pots + pot, effs + MethodCall(pot, symbol)(source))
       else if (symbol.isOneOf(Flags.Method | Flags.Lazy))
-          (
+          Summary(
             pots + MethodReturn(pot, symbol)(source),
             effs + MethodCall(pot, symbol)(source)
           )
       else
-        (pots + FieldReturn(pot, symbol)(source), effs + FieldAccess(pot, symbol)(source))
+        Summary(pots + FieldReturn(pot, symbol)(source), effs + FieldAccess(pot, symbol)(source))
     }
 
   extension (ps: Potentials) def promote(source: Tree): Effects = ps.map(Promote(_)(source))
@@ -205,13 +197,11 @@ object Potentials {
 
       case Warm(cls, outer2) =>
         // widening to terminate
-        val thisValue2 = thisValue match {
-          case Warm(cls, outer) if outer.level > 2 =>
-            Warm(cls, Cold()(outer2.source))(thisValue.source)
-
-          case _  =>
+        val thisValue2 =
+          if thisValue.level + outer2.level > 4 then
+            Cold()(outer2.source)
+          else
             thisValue
-        }
 
         val outer3 = asSeenFrom(outer2, thisValue2)
         Warm(cls, outer3)(pot.source)