Modified abstract domain in global initialization checker #23138

EnzeXing · 2025-05-12T12:39:24Z

This PR modifies the abstract domain of the global object initialization checker. It closely follows the abstract definitional interpreter framework, but changes the heap to map from scopes (including abstract objects or local environments) to a pair of valsMap and outersMap, both of which over-approximates the information of scope bodies of the concrete scopes they represent.

[test_scala2_library_tasty]

olhotak · 2025-05-20T17:31:42Z

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

-    protected val vars: mutable.Map[Symbol, Heap.Addr] = varsMap
-    protected val outers: mutable.Map[ClassSymbol, Value] = outersMap
+  sealed abstract class Scope(using trace: Trace):
+    // protected val vals: mutable.Map[Symbol, Value] = valsMap


Actually remove this instead of just commenting out.

olhotak · 2025-05-20T17:34:08Z

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

+
+    def outerValue(sym: Symbol)(using Heap.MutableData): ScopeSet = Heap.readOuter(this, sym)
+
+    def outer(using Heap.MutableData): ScopeSet = this.outerValue(meth)


Could we move outerValue and outer down to the subclasses where they make sense (presumably Ref for outerValue and LocalEnv for outer)? I worry about calling the wrong one by accident.

olhotak · 2025-05-20T17:39:44Z

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

-    val owner = klass
+  case class ObjectRef(
+    klass: ClassSymbol
+  )(using context: Context, @constructorOnly heap: Heap.MutableData, trace: Trace) extends Ref:


Could we avoid these using parameters if we had an apply method like for OfClass?

It feels dangerous for the ObjectRef instance to implicitly be capturing references to these inherently local things.

olhotak · 2025-05-20T17:41:08Z

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

+    def meth = defn.ArrayConstructor
+    def klass: ClassSymbol = defn.ArrayClass
+
+    val contentSymbol = defn.ArrayConstructor


Is this unused? You use meth below.

olhotak · 2025-05-20T17:42:04Z

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

+   *  UnknownValue is not ValueElement since RefSet containing UnknownValue
+   *  is equivalent to UnknownValue
+   */
+  case object UnknownValue extends ValueElement:


The extends clause contradicts the comment.

olhotak · 2025-05-20T17:52:50Z

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

    def show(using Context) = "OfArray(owner = " + owner.show + ")"
+    def content(using Heap.MutableData) = valValue(meth)


Consider element instead of content.

Also readElement and writeElement to match readVal and writeVal.

olhotak · 2025-05-20T17:59:21Z

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

@@ -1128,7 +1151,7 @@ class Objects(using Context @constructorOnly):
   * @param ctor        The symbol of the target constructor.
   * @param args        The arguments passsed to the constructor.
   */
-  def instantiate(outer: Value, klass: ClassSymbol, ctor: Symbol, args: List[ArgInfo]): Contextual[Value] = log("instantiating " + klass.show + ", outer = " + outer + ", args = " + args.map(_.value.show), printer, (_: Value).show) {
+  def instantiate(outer: Value, klass: ClassSymbol, ctor: Symbol, args: List[ArgInfo], typeArgs: List[Type]): Contextual[Value] = log("instantiating " + klass.show + ", outer = " + outer + ", args = " + args.map(_.value.show), printer, (_: Value).show) {


What are the typeArgs used for?

olhotak · 2025-05-20T18:03:40Z

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

    if classSym.hasSource then
      State.checkObjectAccess(classSym)
    else
      ObjectRef(classSym)
  }


-  def checkClasses(classes: List[ClassSymbol])(using Context): Unit =
+  def checkClasses(classes: List[ClassSymbol])(using Context) =


Why remove the return type?

olhotak · 2025-05-20T18:07:49Z

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

@@ -2032,33 +2033,35 @@ class Objects(using Context @constructorOnly):
      resolveThis(enclosing, thisV, klass, elideObjectAccess = cls.isStatic)
    else
      if cls.isAllOf(Flags.JavaInterface) then Bottom
-      else evalType(tref.prefix, thisV, klass, elideObjectAccess = cls.isStatic)
+      else


This change doesn't change the meaning. Undo to preserve history.

liufengyun

I like this redesign, great work @EnzeXing 🎉

I left some comments, but I see no issue block the merge given that we expect further PRs coming up soon.

@EnzeXing You can decide which comments to address in this PR and which are left to later PRs.

We can discuss the comment related to Cartesian Product Algorithm in next meeting.

liufengyun · 2025-05-21T08:57:29Z

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

+   * ThisValue ::= Ref | vs                                              // possible values for 'this'
+   * LocalEnv(meth, ownerObject)                                         // represents environments for methods or functions
+   * Scope ::= Ref | LocalEnv
+   * ScopeSet ::= Set(Scope)


Minor: The name Scope, ScopeSet, and LocalEnv are actually keys to the heap. ScopeBody is not intuitive enough. Better names will help understanding and maintenance.

It's a minor issue (the same for other naming issues mentioned below), we can delay it to a later PR if it's not easy to come up with better names.

liufengyun · 2025-05-21T08:57:58Z

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

-   *        | fieldVarAddr(regions, valsym, owner)                       // independent of OfClass/ObjectRef
-   *        | arrayAddr(regions, owner)                                  // independent of array element type
+   * valsMap = sym -> val                                                // maps variables to their values
+   * outersMap = classSym -> ScopeSEt                                    // maps the possible outer scopes for a corresponding (parent) class


Typo: ScopeSEt -> ScopeSet

liufengyun · 2025-05-21T09:06:38Z

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


-    def varAddr(sym: Symbol): Heap.Addr = vars(sym)
+    def meth: Symbol


It seems meth have different meaning depending on whether the underlying type is Ref or LocalEnv.

It might be better to have easier cast .asRef/.asEnvAddr and then access the respective members instead of unifying them with unclear semantics. It aligns with Ondrej's comment about outer.

liufengyun · 2025-05-21T09:15:43Z

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

-      instance.initOuter(klass, outer)
+      val owner = State.currentObject
+      val instance = new OfClass(klass, owner, ctor, outerScope.level + 1, summon[Regions.Data])
+      instance.initOuter(klass, outerScope)
      instance


Minor: I was thinking, given that now we simplied OfClass, maybe we can remove this helper method.

Advantage: the initialization code for the outer will be at the place where we initialize the object, which will be more regular than before.

liufengyun · 2025-05-21T09:17:38Z

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

-
-      def widen(height: Int)(using Context): Data
-
+    sealed abstract class Data(using Trace) extends Scope:


Can we remove Data as discussed in the meeting?

liufengyun · 2025-05-21T09:47:33Z

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

+  given Join[Value] with
+    extension (a: Value)
+      def join(b: Value): Value =
+        assert(!a.isInstanceOf[Package] && !b.isInstanceOf[Package], "Unexpected join between " + a + " and " + b)


For future: If Package causes troubles and is not essential, we could simply remove it from the abstract domain.

liufengyun · 2025-05-21T09:54:54Z

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

        if sym.is(Flags.Lazy) then
          val rhs = sym.defTree.asInstanceOf[ValDef].rhs
          eval(rhs, thisV, sym.enclosingClass.asClass, cacheResult = true)
        else
          // Assume forward reference check is doing a good job
-          val value = Env.valValue(sym)
+          val value = scopeSet.scopes.map(_.varValue(sym)).join


For future: Might be good to define a helper method in scopeSet to hide the abstract domain details from the semantic logic. It will be more robust to refactoring changes.

liufengyun · 2025-05-21T09:57:18Z

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

    given State.Data = new State.Data
    given Trace = Trace.empty
+    given Heap.MutableData = Heap.empty


Given that now the heap is shared globally, maybe add a TODO to do garbage collection on the heap.

liufengyun · 2025-05-21T10:00:15Z

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

+      res match {
+        case ref: Ref => thisV.initOuter(cls, ScopeSet(Set(ref)))
+        case ValueSet(values) if values.forall(_.isInstanceOf[Ref]) =>
+          thisV.initOuter(cls, ScopeSet(values.map(_.asInstanceOf[Ref])))


The map can be avoided by doing the cast directly: values.asInstanceOf[..]

liufengyun · 2025-05-21T10:01:59Z

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

+            recur(scopeSet.scopes.map(_.outer).join)
+        else
+          recur(scopeSet.scopes.map(_.outer).join)
+    end recur


For future: if possible, try to hide abstract domain details from the semantic logic. That would make the code more robust against refactoring and easier to understand.

EnzeXing force-pushed the global-init-checker-redesign branch from 5591de9 to dbdfe1a Compare May 19, 2025 04:59

EnzeXing changed the title ~~WIP: Modified abstract domain in global initialization checker~~ Modified abstract domain in global initialization checker May 19, 2025

EnzeXing added 3 commits May 20, 2025 15:30

Modified abstract domain

d714689

Further modification; update tests

ffb3739

Update documentation

7582cf9

EnzeXing force-pushed the global-init-checker-redesign branch from dbdfe1a to 7582cf9 Compare May 20, 2025 07:30

EnzeXing marked this pull request as ready for review May 20, 2025 07:33

olhotak reviewed May 20, 2025

View reviewed changes

liufengyun approved these changes May 21, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Modified abstract domain in global initialization checker #23138

Modified abstract domain in global initialization checker #23138

EnzeXing commented May 12, 2025 •

edited by liufengyun

Loading

olhotak May 20, 2025

olhotak May 20, 2025

olhotak May 20, 2025

olhotak May 20, 2025

olhotak May 20, 2025

olhotak May 20, 2025

olhotak May 20, 2025

olhotak May 20, 2025

olhotak May 20, 2025

olhotak May 20, 2025

liufengyun left a comment

liufengyun May 21, 2025

liufengyun May 21, 2025

liufengyun May 21, 2025

liufengyun May 21, 2025

liufengyun May 21, 2025

liufengyun May 21, 2025

liufengyun May 21, 2025

liufengyun May 21, 2025

liufengyun May 21, 2025

liufengyun May 21, 2025


		def outerValue(sym: Symbol)(using Heap.MutableData): ScopeSet = Heap.readOuter(this, sym)

		def outer(using Heap.MutableData): ScopeSet = this.outerValue(meth)

		def show(using Context) = "OfArray(owner = " + owner.show + ")"
		def content(using Heap.MutableData) = valValue(meth)


		def varAddr(sym: Symbol): Heap.Addr = vars(sym)
		def meth: Symbol


		def widen(height: Int)(using Context): Data

		sealed abstract class Data(using Trace) extends Scope:

Modified abstract domain in global initialization checker #23138

Are you sure you want to change the base?

Modified abstract domain in global initialization checker #23138

Conversation

EnzeXing commented May 12, 2025 • edited by liufengyun Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

liufengyun left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

EnzeXing commented May 12, 2025 •

edited by liufengyun

Loading