Resolving cases for def-tree

Author: EnzeXing

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

@@ -790,13 +790,11 @@ class Semantic {
         Result(value, Nil)
 
       case Block(stats, expr) =>
-        val (ress, env2) = eval(stats, thisV, klass)
-        withEnv(env2) {
-          eval(expr, thisV, klass) ++ ress.flatMap(_.errors)
-        }
+        val ress = eval(stats, thisV, klass)
+        eval(expr, thisV, klass) ++ ress.flatMap(_.errors)
 
       case If(cond, thenp, elsep) =>
-        val (ress, env2) = eval(cond :: thenp :: elsep :: Nil, thisV, klass)
+        val ress = eval(cond :: thenp :: elsep :: Nil, thisV, klass)
         val value = ress.map(_.value).join
         val errors = ress.flatMap(_.errors)
         Result(value, errors)
@@ -807,7 +805,7 @@ class Semantic {
 
       case Match(selector, cases) =>
         val res1 = eval(selector, thisV, klass).ensureHot("The value to be matched needs to be fully initialized", selector)
-        val (ress, env) = eval(cases.map(_.body), thisV, klass)
+        val ress = eval(cases.map(_.body), thisV, klass)
         val value = ress.map(_.value).join
         val errors = res1.errors ++ ress.flatMap(_.errors)
         Result(value, errors)
@@ -816,15 +814,15 @@ class Semantic {
         eval(expr, thisV, klass).ensureHot("return expression may only be initialized value", expr)
 
       case WhileDo(cond, body) =>
-        val (ress, env2) = eval(cond :: body :: Nil, thisV, klass)
+        val ress = eval(cond :: body :: Nil, thisV, klass)
         Result(Hot, ress.flatMap(_.errors))
 
       case Labeled(_, expr) =>
         eval(expr, thisV, klass)
 
       case Try(block, cases, finalizer) =>
         val res1 = eval(block, thisV, klass)
-        val (ress, env2) = eval(cases.map(_.body), thisV, klass)
+        val ress = eval(cases.map(_.body), thisV, klass)
         val errors = ress.flatMap(_.errors)
         val resValue = ress.map(_.value).join
         if finalizer.isEmpty then
@@ -840,7 +838,7 @@ class Semantic {
         Result(Hot, ress.flatMap(_.errors))
 
       case Inlined(call, bindings, expansion) =>
-        val (ress, env2) = eval(bindings, thisV, klass)
+        val ress = eval(bindings, thisV, klass)
         eval(expansion, thisV, klass) ++ ress.flatMap(_.errors)
 
       case Thicket(List()) =>
@@ -896,10 +894,27 @@ class Semantic {
             // It's always safe to approximate them with `Cold`.
             Result(Cold, Nil)
         else
-          // resolve this for local variable
-          val enclosingClass = sym.owner.enclosingClass.asClass
-          val thisValue2 = resolveThis(enclosingClass, thisV, klass, source)
-
+          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()
+          }
+          
       case tmref: TermRef =>
         cases(tmref.prefix, thisV, klass, source).select(tmref.symbol, source)
 
@@ -994,7 +1009,7 @@ class Semantic {
     // parents
     def initParent(parent: Tree, tasks: Tasks)(using Env) = parent match {
       case tree @ Block(stats, NewExpr(tref, New(tpt), ctor, argss)) =>  // can happen
-        eval(stats, thisV, klass)._1.foreach { res => errorBuffer ++= res.errors }
+        eval(stats, thisV, klass).foreach { res => errorBuffer ++= res.errors }
         val (errors, args) = evalArgs(argss.flatten, thisV, klass)
         errorBuffer ++= errors
         superCall(tref, ctor, args, tree, tasks)