Some cleanup and fix test case

Author: q-ata

Diff for: compiler/src/dotty/tools/dotc/transform/init/Objects.scala

@@ -410,7 +410,6 @@ class Objects(using Context @constructorOnly):
       new LocalEnv(argMap, meth, outer)(valsMap = mutable.Map.empty, varsMap = mutable.Map.empty)
 
     def ofDefDef(ddef: DefDef, args: List[Value], outer: Data)(using Context): Data =
-      // println(ddef.show)
       val params = ddef.termParamss.flatten.map(_.symbol)
       assert(args.size == params.size, "arguments = " + args.size + ", params = " + params.size)
       assert(ddef.symbol.owner.isClass ^ (outer != NoEnv), "ddef.owner = " + ddef.symbol.owner.show + ", outer = " + outer + ", " + ddef.source)
@@ -439,47 +438,54 @@ class Objects(using Context @constructorOnly):
         throw new RuntimeException("Incorrect local environment for initializing " + x.show)
 
     /**
-     * Resolve the environment owned by the given method.
+     * Resolve the environment by searching for a given symbol.
      *
-     * The method could be located in outer scope with intermixed classes between its definition
-     * site and usage site.
+     * Searches for the environment that owns `target`, starting from `env` as the innermost.
      *
      * Due to widening, the corresponding environment might not exist. As a result reading the local
      * variable will return `Cold` and it's forbidden to write to the local variable.
      *
-     * @param meth  The method which owns the environment
+     * @param target  The symbol to search for.
      * @param thisV The value for `this` of the enclosing class where the local variable is referenced.
      * @param env   The local environment where the local variable is referenced.
      *
-     * @return the environment and value for `this` owned by the given method.
+     * @return the environment that owns the `target` and value for `this` owned by the given method.
      */
-    def _resolveEnvByValue(target: Symbol, thisV: ThisValue, env: Data)(using Context): Option[(ThisValue, Data)] = log("Resolving env for " + target.show + ", this = " + thisV.show + ", env = " + env.show, printer) {
+    def resolveEnvByValue(target: Symbol, thisV: ThisValue, env: Data)(using Context): Option[(ThisValue, Data)] = log("Resolving env by value for " + target.show + ", this = " + thisV.show + ", env = " + env.show, printer) {
       env match
       case localEnv: LocalEnv =>
         if localEnv.getVal(target).isDefined then Some(thisV -> localEnv)
         else if localEnv.getVar(target).isDefined then Some(thisV -> localEnv)
-        else _resolveEnvByValue(target, thisV, localEnv.outer)
+        else resolveEnvByValue(target, thisV, localEnv.outer)
       case NoEnv =>
         thisV match
         case ref: OfClass =>
           ref.outer match
           case outer : ThisValue =>
-            _resolveEnvByValue(target, outer, ref.env)
+            resolveEnvByValue(target, outer, ref.env)
           case _ =>
             // TODO: properly handle the case where ref.outer is ValueSet
             None
         case _ =>
           None
     }
 
-    def resolveEnvByValue(target: Symbol, thisV: ThisValue, env: Data)(using Context): Option[(ThisValue, Data)] =
-      // println("the target: " + target.show + "its owner: " + target.owner.show + " the env: " + env.show)
-      val e = _resolveEnvByValue(target, thisV, env)
-      if e.isDefined then println(e.get._2.show)
-      else println("NONE")
-      e
-
-    def resolveEnvByOwner(meth: Symbol, thisV: ThisValue, env: Data)(using Context): Option[(ThisValue, Data)] = log("Resolving env for " + meth.show + ", this = " + thisV.show + ", env = " + env.show, printer) {
+    /**
+     * Resolve the environment owned by the given method.
+     *
+     * The method could be located in outer scope with intermixed classes between its definition
+     * site and usage site.
+     *
+     * Due to widening, the corresponding environment might not exist. As a result reading the local
+     * variable will return `Cold` and it's forbidden to write to the local variable.
+     *
+     * @param meth  The method which owns the environment
+     * @param thisV The value for `this` of the enclosing class where the local variable is referenced.
+     * @param env   The local environment where the local variable is referenced.
+     *
+     * @return the environment and value for `this` owned by the given method.
+     */
+    def resolveEnvByOwner(meth: Symbol, thisV: ThisValue, env: Data)(using Context): Option[(ThisValue, Data)] = log("Resolving env by owner for " + meth.show + ", this = " + thisV.show + ", env = " + env.show, printer) {
       env match
       case localEnv: LocalEnv =>
         if localEnv.meth == meth then Some(thisV -> env)
@@ -752,7 +758,6 @@ class Objects(using Context @constructorOnly):
             if meth.owner.isClass then
               (ref, Env.NoEnv)
             else
-              // println("1: " + meth.show + " env : " + summon[Env.Data].show)
               Env.resolveEnvByOwner(meth.owner.enclosingMethod, ref, summon[Env.Data]).getOrElse(Cold -> Env.NoEnv)
 
           val env2 = Env.ofDefDef(ddef, args.map(_.value), outerEnv)
@@ -991,7 +996,6 @@ class Objects(using Context @constructorOnly):
                   (thisV.widenRefOrCold(1), Env.NoEnv)
               else
                 // klass.enclosingMethod returns its primary constructor
-                // println("callsite 2: " + klass.show + " env : " + summon[Env.Data].show)
                 Env.resolveEnvByOwner(klass.owner.enclosingMethod, thisV, summon[Env.Data]).getOrElse(Cold -> Env.NoEnv)
 
         val instance = OfClass(klass, outerWidened, ctor, args.map(_.value), envWidened)
@@ -1022,7 +1026,8 @@ class Objects(using Context @constructorOnly):
    */
   def readLocal(thisV: ThisValue, sym: Symbol): Contextual[Value] = log("reading local " + sym.show, printer, (_: Value).show) {
     def isByNameParam(sym: Symbol) = sym.is(Flags.Param) && sym.info.isInstanceOf[ExprType]
-    // println("callsite 3: " + sym.show + " env : " + summon[Env.Data].show)
+    // Can't use enclosingMethod here because values defined in a by-name closure will have the wrong enclosingMethod,
+    // since our phase is before elimByName.
     Env.resolveEnvByValue(sym, thisV, summon[Env.Data]) match
     case Some(thisV -> env) =>
       if sym.is(Flags.Mutable) then
@@ -1078,7 +1083,8 @@ class Objects(using Context @constructorOnly):
    */
   def writeLocal(thisV: ThisValue, sym: Symbol, value: Value): Contextual[Value] = log("write local " + sym.show + " with " + value.show, printer, (_: Value).show) {
     assert(sym.is(Flags.Mutable), "Writing to immutable variable " + sym.show)
-    // println("callsite 4: " + sym.show + " env : " + summon[Env.Data].show)
+    // Can't use enclosingMethod here because values defined in a by-name closure will have the wrong enclosingMethod,
+    // since our phase is before elimByName.
     Env.resolveEnvByValue(sym, thisV, summon[Env.Data]) match
     case Some(thisV -> env) =>
       given Env.Data = env
@@ -1215,7 +1221,6 @@ class Objects(using Context @constructorOnly):
             withTrace(trace2) { call(receiver, ref.symbol, args, receiver = qual.tpe, superType = NoType) }
 
         case id: Ident =>
-          // println("ID : " + id.show)
           id.tpe match
           case TermRef(NoPrefix, _) =>
             // resolve this for the local method
@@ -1285,7 +1290,6 @@ class Objects(using Context @constructorOnly):
         Fun(ddef, thisV, klass, summon[Env.Data])
 
       case Block(stats, expr) =>
-        // println("BLOCK DATA : " + expr.show)
         evalExprs(stats, thisV, klass)
         eval(expr, thisV, klass)
 

Diff for: tests/init/pos/byname.scala renamed to tests/init-global/pos/byname.scala

@@ -5,12 +5,12 @@ class A extends T:
   override def bar(i: => Int): Int = i + 1
 
 class B extends T:
-  override def bar(i: => Int): Int = i + 2
+  override def bar(i: => Int): Int = i
 
 object A:
   val a: T = if ??? then new A else new B
-  def foo(b: List[Int]) = a.bar(b match {
-    case x :: xs => 1
+  def foo(b: List[Int]): Int = a.bar(b match {
+    case head :: rest => head + foo(rest) + a.bar(head)
     case Nil => 0
   })
 

Diff for: tests/init-global/warn/lazy-local-val.scala

@@ -15,5 +15,5 @@ object B:
     lazy val b = a
     Box(b)
 
-  val box = f(n)   // warn
+  val box = f(n)
   val n = 10