Add eval-static-fields test

Author: adpi2

compiler/src/dotty/tools/debug/ResolveReflectEval.scala

@@ -57,15 +57,15 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
               JavaEncoding.encode(typeSymbol) match
                 case s"scala.runtime.${_}Ref" =>
                   val elemField = typeSymbol.info.decl(termName("elem")).symbol
-                  gen.setField(
+                  gen.setField(tree)(
                     gen.getLocalValue(variableName),
                     elemField.asTerm,
                     value
                   )
                 case _ => gen.setLocalValue(variableName, value)
             case ReflectEvalStrategy.ClassCapture(variable, cls, isByName) =>
               val rawCapture = gen
-                .getClassCapture(qualifier, variable.name, cls)
+                .getClassCapture(tree)(qualifier, variable.name, cls)
                 .getOrElse {
                   report.error(s"No capture found for $variable in $cls", tree.srcPos)
                   ref(defn.Predef_undefined)
@@ -75,15 +75,15 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
               gen.boxIfValueClass(variable, capturedValue)
             case ReflectEvalStrategy.ClassCaptureAssign(variable, cls) =>
               val capture = gen
-                .getClassCapture(qualifier, variable.name, cls)
+                .getClassCapture(tree)(qualifier, variable.name, cls)
                 .getOrElse {
                   report.error(s"No capture found for $variable in $cls", tree.srcPos)
                   ref(defn.Predef_undefined)
                 }
               val value = gen.unboxIfValueClass(variable, args.head)
               val typeSymbol = variable.info.typeSymbol
               val elemField = typeSymbol.info.decl(termName("elem")).symbol
-              gen.setField(capture, elemField.asTerm, value)
+              gen.setField(tree)(capture, elemField.asTerm, value)
             case ReflectEvalStrategy.MethodCapture(variable, method, isByName) =>
               val rawCapture = gen
                 .getMethodCapture(method, variable.name)
@@ -104,24 +104,25 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
               val value = gen.unboxIfValueClass(variable, args.head)
               val typeSymbol = variable.info.typeSymbol
               val elemField = typeSymbol.info.decl(termName("elem")).symbol
-              gen.setField(capture, elemField.asTerm, value)
+              gen.setField(tree)(capture, elemField.asTerm, value)
             case ReflectEvalStrategy.StaticObject(obj) => gen.getStaticObject(obj)
             case ReflectEvalStrategy.Field(field, isByName) =>
               // if the field is lazy, if it is private in a value class or a trait
               // then we must call the getter method
               val fieldValue =
                 if field.is(Lazy) || field.owner.isValueClass || field.owner.is(Trait)
-                then gen.callMethod(qualifier, field.getter.asTerm, Nil)
+                then gen.callMethod(tree)(qualifier, field.getter.asTerm, Nil)
                 else
-                  val rawValue = gen.getField(qualifier, field)
+                  val rawValue = gen.getField(tree)(qualifier, field)
                   if isByName then gen.evaluateByName(rawValue) else rawValue
               gen.boxIfValueClass(field, fieldValue)
             case ReflectEvalStrategy.FieldAssign(field) =>
               val arg = gen.unboxIfValueClass(field, args.head)
-              if field.owner.is(Trait) then gen.callMethod(qualifier, field.setter.asTerm, List(arg))
-              else gen.setField(qualifier, field, arg)
-            case ReflectEvalStrategy.MethodCall(method) => gen.callMethod(qualifier, method, args)
-            case ReflectEvalStrategy.ConstructorCall(ctr, cls) => gen.callConstructor(qualifier, ctr, args)
+              if field.owner.is(Trait) then
+                gen.callMethod(tree)(qualifier, field.setter.asTerm, List(arg))
+              else gen.setField(tree)(qualifier, field, arg)
+            case ReflectEvalStrategy.MethodCall(method) => gen.callMethod(tree)(qualifier, method, args)
+            case ReflectEvalStrategy.ConstructorCall(ctr, cls) => gen.callConstructor(tree)(qualifier, ctr, args)
         case _ => super.transform(tree)
 
   private def isReflectEval(symbol: Symbol)(using Context): Boolean =
@@ -135,7 +136,7 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
       JavaEncoding.encode(typeSymbol) match
         case s"scala.runtime.${_}Ref" =>
           val elemField = typeSymbol.info.decl(termName("elem")).symbol
-          getField(tree, elemField.asTerm)
+          getField(tree)(tree, elemField.asTerm)
         case _ => tree
 
     def boxIfValueClass(term: TermSymbol, tree: Tree): Tree =
@@ -147,7 +148,7 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
     def boxValueClass(valueClass: ClassSymbol, tree: Tree): Tree =
       // qualifier is null: a value class cannot be nested into a class
       val ctor = valueClass.primaryConstructor.asTerm
-      callConstructor(nullLiteral, ctor, List(tree))
+      callConstructor(tree)(nullLiteral, ctor, List(tree))
 
     def unboxIfValueClass(term: TermSymbol, tree: Tree): Tree =
       getErasedValueType(atPhase(Phases.elimErasedValueTypePhase)(term.info)) match
@@ -162,7 +163,7 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
     private def unboxValueClass(tree: Tree, tpe: ErasedValueType): Tree =
       val cls = tpe.tycon.typeSymbol.asClass
       val unboxMethod = ValueClasses.valueClassUnbox(cls).asTerm
-      callMethod(tree, unboxMethod, Nil)
+      callMethod(tree)(tree, unboxMethod, Nil)
 
     def getThisObject: Tree =
       Apply(Select(expressionThis, termName("getThisObject")), List.empty)
@@ -185,7 +186,7 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
         List(qualifier, Literal(Constant(JavaEncoding.encode(outerCls))))
       )
 
-    def getClassCapture(qualifier: Tree, originalName: Name, cls: ClassSymbol): Option[Tree] =
+    def getClassCapture(tree: Tree)(qualifier: Tree, originalName: Name, cls: ClassSymbol): Option[Tree] =
       cls.info.decls.iterator
         .filter(term => term.isField)
         .find { field =>
@@ -196,7 +197,7 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
               info.name == originalName
             case _ => false
         }
-        .map(field => getField(qualifier, field.asTerm))
+        .map(field => getField(tree: Tree)(qualifier, field.asTerm))
 
     def getMethodCapture(method: TermSymbol, originalName: TermName): Option[Tree] =
       val methodType = method.info.asInstanceOf[MethodType]
@@ -210,32 +211,40 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
         List(Literal(Constant(JavaEncoding.encode(obj))))
       )
 
-    def getField(qualifier: Tree, field: TermSymbol): Tree =
-      Apply(
-        Select(expressionThis, termName("getField")),
-        List(
-          qualifier,
-          Literal(Constant(JavaEncoding.encode(field.owner.asType))),
-          Literal(Constant(JavaEncoding.encode(field.name)))
+    def getField(tree: Tree)(qualifier: Tree, field: TermSymbol): Tree =
+      if field.owner.isTerm then
+        report.error(s"Cannot access local val ${field.name} in ${field.owner} as field", tree.srcPos)
+        ref(defn.Predef_undefined)
+      else
+        Apply(
+          Select(expressionThis, termName("getField")),
+          List(
+            qualifier,
+            Literal(Constant(JavaEncoding.encode(field.owner.asType))),
+            Literal(Constant(JavaEncoding.encode(field.name)))
+          )
         )
-      )
 
-    def setField(qualifier: Tree, field: TermSymbol, value: Tree): Tree =
-      Apply(
-        Select(expressionThis, termName("setField")),
-        List(
-          qualifier,
-          Literal(Constant(JavaEncoding.encode(field.owner.asType))),
-          Literal(Constant(JavaEncoding.encode(field.name))),
-          value
+    def setField(tree: Tree)(qualifier: Tree, field: TermSymbol, value: Tree): Tree =
+      if field.owner.isTerm then
+        report.error(s"Cannot access local var ${field.name} in ${field.owner} as field", tree.srcPos)
+        ref(defn.Predef_undefined)
+      else
+        Apply(
+          Select(expressionThis, termName("setField")),
+          List(
+            qualifier,
+            Literal(Constant(JavaEncoding.encode(field.owner.asType))),
+            Literal(Constant(JavaEncoding.encode(field.name))),
+            value
+          )
         )
-      )
 
     def evaluateByName(function: Tree): Tree =
       val castFunction = function.cast(defn.Function0.typeRef.appliedTo(defn.AnyType))
       Apply(Select(castFunction, termName("apply")), List())
 
-    def callMethod(qualifier: Tree, method: TermSymbol, args: List[Tree]): Tree =
+    def callMethod(tree: Tree)(qualifier: Tree, method: TermSymbol, args: List[Tree]): Tree =
       val methodType = method.info.asInstanceOf[MethodType]
       val paramTypesNames = methodType.paramInfos.map(JavaEncoding.encode)
       val paramTypesArray = JavaSeqLiteral(
@@ -247,7 +256,7 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
         report.error(s"Unknown captured variable $name in $method", reflectEval.srcPos)
         ref(defn.Predef_undefined)
       val capturedArgs = methodType.paramNames.dropRight(args.size).map {
-        case name @ DerivedName(underlying, _) => capturedValue(method, underlying).getOrElse(unknownCapture(name))
+        case name @ DerivedName(underlying, _) => capturedValue(tree)(method, underlying).getOrElse(unknownCapture(name))
         case name => unknownCapture(name)
       }
 
@@ -275,7 +284,7 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
         case _ => result
     end callMethod
 
-    def callConstructor(qualifier: Tree, ctr: TermSymbol, args: List[Tree]): Tree =
+    def callConstructor(tree: Tree)(qualifier: Tree, ctr: TermSymbol, args: List[Tree]): Tree =
       val methodType = ctr.info.asInstanceOf[MethodType]
       val paramTypesNames = methodType.paramInfos.map(JavaEncoding.encode)
       val clsName = JavaEncoding.encode(methodType.resType)
@@ -285,7 +294,7 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
           case outer if outer.toString == "$outer" => qualifier
           case name @ DerivedName(underlying, _) =>
             // if derived then probably a capture
-            capturedValue(ctr.owner, underlying)
+            capturedValue(tree: Tree)(ctr.owner, underlying)
               .getOrElse {
                 report.error(s"Unknown captured variable $name in $ctr of ${ctr.owner}", reflectEval.srcPos)
                 ref(defn.Predef_undefined)
@@ -316,22 +325,22 @@ private class ResolveReflectEval(config: ExpressionCompilerConfig, expressionSto
       )
     end callConstructor
 
-    private def capturedValue(sym: Symbol, originalName: TermName): Option[Tree] =
+    private def capturedValue(tree: Tree)(sym: Symbol, originalName: TermName): Option[Tree] =
       val encodedName = JavaEncoding.encode(originalName)
-      if expressionStore.classOwners.contains(sym) then capturedByClass(sym.asClass, originalName)
+      if expressionStore.classOwners.contains(sym) then capturedByClass(tree: Tree)(sym.asClass, originalName)
       else if config.localVariables.contains(encodedName) then Some(getLocalValue(encodedName))
       else
         // if the captured value is not a local variables
         // then it must have been captured by the outer method
         expressionStore.capturingMethod.flatMap(getMethodCapture(_, originalName))
 
-    private def capturedByClass(cls: ClassSymbol, originalName: TermName): Option[Tree] =
+    private def capturedByClass(tree: Tree)(cls: ClassSymbol, originalName: TermName): Option[Tree] =
       val target = expressionStore.classOwners.indexOf(cls)
       val qualifier = expressionStore.classOwners
         .drop(1)
         .take(target)
         .foldLeft(getThisObject)((q, cls) => getOuter(q, cls))
-      getClassCapture(qualifier, originalName, cls)
+      getClassCapture(tree: Tree)(qualifier, originalName, cls)
 
 private object ResolveReflectEval:
   val name = "resolve-reflect-eval"

compiler/test/dotty/tools/debug/DebugStepAssert.scala

@@ -81,7 +81,7 @@ private[debug] object DebugStepAssert:
       case Left(obtained) =>
         val message =
           s"""|Evaluation failed:
-              |$obtained""".stripMargin
+              |${obtained.replace("\n", "\n|")}""".stripMargin
         throw new AssertionError(message)
       case Right(obtained) =>
         val message =
@@ -96,7 +96,7 @@ private[debug] object DebugStepAssert:
           s"""|Expected:
               |${expected.mkString("\n")}
               |Obtained:
-              |$obtained""".stripMargin
+              |${obtained.replace("\n", "\n|")}""".stripMargin
         assert(expected.forall(e => e.r.findFirstMatchIn(obtained).isDefined), message)
       case Right(obtained) =>
         val message =

compiler/test/dotty/tools/debug/DebugTests.scala

@@ -8,16 +8,19 @@ import dotty.tools.vulpix.*
 import org.junit.Test
 
 import scala.concurrent.duration.*
+import scala.util.control.NonFatal
 
 class DebugTests:
   import DebugTests.*
   @Test def debug: Unit =
     implicit val testGroup: TestGroup = TestGroup("debug")
-    // compileFile("tests/debug/for.scala", TestConfiguration.defaultOptions).checkDebug()
+    // compileFile("tests/debug/eval-static-fields.scala", TestConfiguration.defaultOptions).checkDebug()
     compileFilesInDir("tests/debug", TestConfiguration.defaultOptions).checkDebug()
 
 object DebugTests extends ParallelTesting:
-  def maxDuration = 45.seconds
+  def maxDuration =
+    // Increase the timeout when the user is debugging the tests
+    if isUserDebugging then 3.hours else 45.seconds
   def numberOfSlaves = Runtime.getRuntime().availableProcessors()
   def safeMode = Properties.testsSafeMode
   def isInteractive = SummaryReport.isInteractive
@@ -99,7 +102,10 @@ object DebugTests extends ParallelTesting:
             if verbose then println(s"step ${location.lineNumber}")
             assert(location)
           case DebugStepAssert(Eval(expr), assert) =>
-            val result = debugger.evaluate(expr, thread)
+            val result =
+              try debugger.evaluate(expr, thread)
+              catch case NonFatal(cause) =>
+                throw new Exception(s"Evaluation of $expr failed", cause)
             if verbose then println(s"eval $expr $result")
             assert(result)
     end playDebugSteps

tests/debug/eval-static-fields.check

@@ -0,0 +1,36 @@
+break example.A$ 8
+eval a1
+result a1
+eval this.a2
+result a2
+eval A.a3
+result a3
+eval B
+result example.A.B
+eval this.B.b1
+result b1
+eval A.B.b2
+error value b2 cannot be accessed
+eval B.b3
+result b3
+eval C.c1
+result c1
+eval D.d1
+result d1
+eval E
+result example.E
+eval E.e1
+result e1
+
+// eval static fields from private object
+break example.A$B$ 16
+eval b1
+result b1
+eval b2
+error Cannot access local val b2 in method <init> as field
+eval a2
+result a2
+eval C.c1
+result c1
+eval E.e1
+result e1

tests/debug/eval-static-fields.scala

@@ -0,0 +1,30 @@
+object Test:
+  def main(args: Array[String]): Unit =
+    example.A.m()
+
+package example:
+  object A:
+    def m(): Unit =
+      println("A.m()" + a2)
+      B.m()
+
+    val a1 = "a1"
+    private val a2 = "a2"
+    private[example] val a3 = "a3"
+
+    private object B:
+      def m(): Unit = println("B.m()")
+      val b1 = "b1"
+      private val b2 = "b2"
+      private[A] val b3 = "b3"
+      override def toString: String = "example.A.B"
+
+    private[A] object C:
+      val c1 = "c1"
+
+    object D:
+      val d1 = "d1"
+
+  private object E:
+    val e1 = "e1"
+    override def toString: String = "example.E"