Refactoring accessLocal

EnzeXing · EnzeXing · commit e8e7e1587e33 · 2021-07-28T10:19:26.000-04:00
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Checker.scala b/compiler/src/dotty/tools/dotc/transform/init/Checker.scala
@@ -37,13 +37,13 @@ class Checker extends Phase {
 
   val traverser = new TreeTraverser {
     override def traverse(tree: Tree)(using Context): Unit =
+      traverseChildren(tree)
       tree match {
         case tdef: MemberDef =>
           // self-type annotation ValDef has no symbol
           if tdef.name != nme.WILDCARD then
             tdef.symbol.defTree = tree
         case _ =>
-          traverseChildren(tree)
       }
   }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Errors.scala b/compiler/src/dotty/tools/dotc/transform/init/Errors.scala
@@ -69,7 +69,7 @@ object Errors {
 
   /** Promote `this` under initialization to fully-initialized */
   case class PromoteError(msg: String, source: Tree, trace: Seq[Tree]) extends Error {
-    def show(using Context): String = "Promote the value under initialization to fully-initialized. " + msg + "."
+    def show(using Context): String = "Cannot prove that the value is fully initialized. " + msg + "."
   }
 
   case class AccessCold(field: Symbol, source: Tree, trace: Seq[Tree]) extends Error {
@@ -91,18 +91,14 @@ object Errors {
   /** Promote a value under initialization to fully-initialized */
   case class UnsafePromotion(msg: String, source: Tree, trace: Seq[Tree], errors: Errors) extends Error {
     assert(errors.nonEmpty)
-
     override def issue(using Context): Unit =
       report.warning(show, source.srcPos)
 
     def show(using Context): String = {
       var index = 0
-      "Promoting the value to fully-initialized is unsafe. " + msg + "\n" + stacktrace +
-        "\nThe unsafe promotion may cause the following problem(s):\n" +
-        (errors.flatMap(_.flatten).map { error =>
-          index += 1
-          s"\n$index. " + error.show + error.stacktrace
-        }.mkString)
+      "Cannot prove that the value is fully-initialized. " + msg + ".\n" + stacktrace +
+        "\nThe unsafe promotion may cause the following problem:\n" +
+        errors.head.show + errors.head.stacktrace
     }
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -7,6 +7,7 @@ import Contexts._
 import Symbols._
 import Types._
 import StdNames._
+import NameKinds.OuterSelectName
 
 import ast.tpd._
 import util.EqHashMap
@@ -27,24 +28,20 @@ class Semantic {
    *  Value = Hot | Cold | Warm | ThisRef | Fun | RefSet
    *
    *                 Cold
-   *        ┌──────►  ▲   ◄──┐  ◄────┐
-   *        │         │      │       │
-   *        │         │      │       │
-   *   ThisRef(C)     │      │       │
-   *        ▲         │      │       │
-   *        │     Warm(D)   Fun    RefSet
-   *        │         ▲      ▲       ▲
-   *        │         │      │       │
-   *      Warm(C)     │      │       │
-   *        ▲         │      │       │
-   *        │         │      │       │
-   *        └─────────┴──────┴───────┘
+   *        ┌──────►  ▲  ◄────┐  ◄────┐
+   *        │         │       │       │
+   *        │         │       │       │
+   *        |         │       │       │
+   *        |         │       │       │
+   *   ThisRef(C)  Warm(D)   Fun    RefSet
+   *        │         ▲       ▲       ▲
+   *        │         │       │       │
+   *        |         │       │       │
+   *        ▲         │       │       │
+   *        │         │       │       │
+   *        └─────────┴───────┴───────┘
    *                  Hot
    *
-   *   The most important ordering is the following:
-   *
-   *       Hot ⊑ Warm(C) ⊑ ThisRef(C) ⊑ Cold
-   *
    *   The diagram above does not reflect relationship between `RefSet`
    *   and other values. `RefSet` represents a set of values which could
    *   be `ThisRef`, `Warm` or `Fun`. The following ordering applies for
@@ -301,9 +298,6 @@ class Semantic {
       case (Cold, _) => Cold
       case (_, Cold) => Cold
 
-      case (a: Warm, b: ThisRef) if a.klass == b.klass => b
-      case (a: ThisRef, b: Warm) if a.klass == b.klass => a
-
       case (a: (Fun | Warm | ThisRef), b: (Fun | Warm | ThisRef)) => RefSet(a :: b :: Nil)
 
       case (a: (Fun | Warm | ThisRef), RefSet(refs))    => RefSet(a :: refs)
@@ -406,7 +400,6 @@ class Semantic {
               given Trace = trace1
               val cls = target.owner.enclosingClass.asClass
               val ddef = target.defTree.asInstanceOf[DefDef]
-              // try early promotion here; if returns error, returns cold
               val env2 = Env(ddef, args.map(_.value).widenArgs)
               if target.isPrimaryConstructor then
                 given Env = env2
@@ -497,6 +490,46 @@ class Semantic {
           Result(value2, errors)
       }
     }
+
+    def accessLocal(tmref: TermRef, klass: ClassSymbol, source: Tree): Contextual[Result] =
+      val sym = tmref.symbol
+
+      def default() = Result(Hot, Nil)
+
+      if sym.is(Flags.Param) && sym.owner.isConstructor then
+        // instances of local classes inside secondary constructors cannot
+        // reach here, as those values are abstracted by Cold instead of Warm.
+        // This enables us to simplify the domain without sacrificing
+        // expressiveness nor soundess, as local classes inside secondary
+        // constructors are uncommon.
+        if sym.isContainedIn(klass) then
+          Result(env.lookup(sym), Nil)
+        else
+          // We don't know much about secondary constructor parameters in outer scope.
+          // It's always safe to approximate them with `Cold`.
+          Result(Cold, Nil)
+      else if sym.is(Flags.Param) then
+        default()
+      else
+        sym.defTree match {
+          case vdef: ValDef =>
+            // resolve this for local variable
+            val enclosingClass = sym.owner.enclosingClass.asClass
+            val thisValue2 = resolveThis(enclosingClass, value, klass, source)
+            thisValue2 match {
+              case Hot => Result(Hot, Errors.empty)
+            
+              case Cold => Result(Cold, Nil)
+            
+              case addr: Addr => eval(vdef.rhs, addr, klass)
+                
+              case _ => 
+                report.error("unexpected defTree when accessing local variable, sym = " + sym.show + ", defTree = " + sym.defTree.show, source)
+                default()
+            }
+
+          case _ => default()
+        }
   end extension
 
 // ----- Promotion ----------------------------------------------------
@@ -609,33 +642,24 @@ class Semantic {
       if classRef.memberClasses.nonEmpty || !warm.isFullyFilled then
         return PromoteError(msg, source, trace.toVector) :: Nil
 
-      val fields  = classRef.fields
-      val methods = classRef.membersBasedOnFlags(Flags.Method, Flags.Deferred | Flags.Accessor)
       val buffer  = new mutable.ArrayBuffer[Error]
 
-      fields.exists { denot =>
-        val f = denot.symbol
-        if !f.isOneOf(Flags.Deferred | Flags.Private | Flags.Protected) && f.hasSource then
-          val trace2 = trace.add(f.defTree)
-          val res = warm.select(f, source)
-          locally {
-            given Trace = trace2
-            buffer ++= res.ensureHot(msg, source).errors
-          }
-        buffer.nonEmpty
-      }
-
-      buffer.nonEmpty || methods.exists { denot =>
-        val m = denot.symbol
-        if !m.isConstructor && m.hasSource then
-          val trace2 = trace.add(m.defTree)
-          locally {
-            given Trace = trace2
-            val args = m.info.paramInfoss.flatten.map(_ => ArgInfo(Hot, EmptyTree))
-            val res = warm.call(m, args, superType = NoType, source = source)
-            buffer ++= res.ensureHot(msg, source).errors
-          }
-        buffer.nonEmpty
+      warm.klass.baseClasses.exists { klass =>
+        klass.hasSource && klass.info.decls.exists { member =>
+          if !member.isType && !member.isConstructor && member.hasSource  && !member.is(Flags.Deferred) then
+            if member.is(Flags.Method) then
+              val trace2 = trace.add(source)
+              locally {
+                given Trace = trace2
+                val args = member.info.paramInfoss.flatten.map(_ => ArgInfo(Hot, EmptyTree))
+                val res = warm.call(member, args, superType = NoType, source = member.defTree)
+                buffer ++= res.ensureHot(msg, source).errors
+              }
+            else
+              val res = warm.select(member, source)
+              buffer ++= res.ensureHot(msg, source).errors
+          buffer.nonEmpty
+        }
       }
 
       if buffer.isEmpty then Nil
@@ -694,7 +718,7 @@ class Semantic {
   }
 
   /** Evaluate a list of expressions */
-  def eval(exprs: List[Tree], thisV: Addr, klass: ClassSymbol): Contextual[List[Result]] = 
+  def eval(exprs: List[Tree], thisV: Addr, klass: ClassSymbol): Contextual[List[Result]] =
     exprs.map { expr => eval(expr, thisV, klass) }
 
   /** Evaluate arguments of methods */
@@ -767,7 +791,15 @@ class Semantic {
             res.call(id.symbol, args, superType = NoType, source = expr)
 
       case Select(qualifier, name) =>
-        eval(qualifier, thisV, klass).select(expr.symbol, expr)
+        val qualRes = eval(qualifier, thisV, klass)
+
+        name match
+          case OuterSelectName(_, hops) =>
+            val SkolemType(tp) = expr.tpe
+            val outer = resolveOuterSelect(tp.classSymbol.asClass, qualRes.value, hops, source = expr)
+            Result(outer, qualRes.errors)
+          case _ =>
+            qualRes.select(expr.symbol, expr)
 
       case _: This =>
         cases(expr.tpe, thisV, klass, expr)
@@ -857,8 +889,7 @@ class Semantic {
       case vdef : ValDef =>
         // local val definition
         // TODO: support explicit @cold annotation for local definitions
-        eval(vdef.rhs, thisV, klass, true)
-        // .ensureHot("Local definitions may only hold initialized values", vdef)
+        eval(vdef.rhs, thisV, klass, cacheResult = true)
 
       case ddef : DefDef =>
         // local method
@@ -886,43 +917,7 @@ class Semantic {
         Result(Hot, Errors.empty)
 
       case tmref: TermRef if tmref.prefix == NoPrefix =>
-        val sym = tmref.symbol
-
-        def default() = Result(Hot, Nil)
-
-        if sym.is(Flags.Param) && sym.owner.isConstructor then
-          // instances of local classes inside secondary constructors cannot
-          // reach here, as those values are abstracted by Cold instead of Warm.
-          // This enables us to simplify the domain without sacrificing
-          // expressiveness nor soundess, as local classes inside secondary
-          // constructors are uncommon.
-          if sym.isContainedIn(klass) then
-            Result(env.lookup(sym), Nil)
-          else
-            // We don't know much about secondary constructor parameters in outer scope.
-            // It's always safe to approximate them with `Cold`.
-            Result(Cold, Nil)
-        else
-          sym.defTree match {
-            case vdef: ValDef => {
-              // resolve this for local variable
-              val enclosingClass = sym.owner.enclosingClass.asClass
-              val thisValue2 = resolveThis(enclosingClass, thisV, klass, source)
-              thisValue2 match {
-                case Hot => Result(Hot, Errors.empty)
-                case Cold => {
-                  val error = AccessCold(sym, source, trace.toVector)
-                  Result(Hot, error :: Nil)
-                }
-                case addr: Addr => {
-                  val res = eval(vdef.rhs, addr, klass)
-                  if res.value.promote("Try promote", source).isEmpty then Result(Hot, Errors.empty) else res
-                }
-                case _ => ???
-              }
-            }
-            case _ => default()
-          }
+        thisV.accessLocal(tmref, klass, source)
           
       case tmref: TermRef =>
         cases(tmref.prefix, thisV, klass, source).select(tmref.symbol, source)
@@ -970,6 +965,40 @@ class Semantic {
 
   }
 
+  /** Resolve outer select introduced during inlining.
+   *
+   *  See `tpd.outerSelect` and `ElimOuterSelect`.
+   */
+  def resolveOuterSelect(target: ClassSymbol, thisV: Value, hops: Int, source: Tree): Contextual[Value] = log("resolving outer " + target.show + ", this = " + thisV.show + ", hops = " + hops, printer, res => res.asInstanceOf[Value].show) {
+    // Is `target` reachable from `cls` with the given `hops`?
+    def reachable(cls: ClassSymbol, hops: Int): Boolean =
+      if hops == 0 then cls == target
+      else reachable(cls.lexicallyEnclosingClass.asClass, hops - 1)
+
+    thisV match
+      case Hot => Hot
+
+      case addr: Addr =>
+        val obj = heap(addr)
+        val curOpt = obj.klass.baseClasses.find(cls => reachable(cls, hops))
+        curOpt match
+          case Some(cur) =>
+            resolveThis(target, thisV, cur, source)
+
+          case None =>
+            report.warning("unexpected outerSelect, thisV = " + thisV + ", target = " + target.show + ", hops = " + hops, source.srcPos)
+            Cold
+
+      case RefSet(refs) =>
+        refs.map(ref => resolveOuterSelect(target, ref, hops, source)).join
+
+      case fun: Fun =>
+        report.warning("unexpected thisV = " + thisV + ", target = " + target.show + ", hops = " + hops, source.srcPos)
+        Cold
+
+      case Cold => Cold
+  }
+
   /** Compute the outer value that correspond to `tref.prefix` */
   def outerValue(tref: TypeRef, thisV: Addr, klass: ClassSymbol, source: Tree): Contextual[Result] =
     val cls = tref.classSymbol.asClass

Original file line number	Diff line number	Diff line change
`@@ -37,13 +37,13 @@ class Checker extends Phase {`
`37`	`37`
`38`	`38`	`val traverser = new TreeTraverser {`
`39`	`39`	`override def traverse(tree: Tree)(using Context): Unit =`
	`40`	`+ traverseChildren(tree)`
`40`	`41`	`tree match {`
`41`	`42`	`case tdef: MemberDef =>`
`42`	`43`	`// self-type annotation ValDef has no symbol`
`43`	`44`	`if tdef.name != nme.WILDCARD then`
`44`	`45`	`tdef.symbol.defTree = tree`
`45`	`46`	`case _ =>`
`46`		`- traverseChildren(tree)`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`