Foundations for the optimizer & cleanup by SolalPirelli · Pull Request #25187 · scala/scala3

SolalPirelli · 2026-02-04T10:15:43Z

Prerequisite for #25165, extracting the stuff that touches the backend without actually being the optimizer, and cleaning up the overall architecture so it can be layered (this is especially important when adding back the optimizer so it's understandable...)

I realize this PR is a little larger than is reasonable, sorry about that. Part of the point of the refactoring was that by following the code flow and simplifying it I got an understanding of how the JVM backend works...

Main changes:

BType and its implementations are top-level now, no longer members of a module-like class
CoreBTypes is passed explicitly where needed
BTypesFromSymbols integrated into CoreBTypesFromSymbols (since its parent BTypes no longer exists)
CoreBTypesFromSymbols moved to its own file
DottyBackendInterface is an object only, the stateful stuff it did has been inlined where it was needed
(Most) classes now take their dependencies as constructor parameters, instead of "magically" importing what they need from bTypes/int/postProcessor. This makes dependencies explicit, and allowed me to remove some unneeded cycles in the object graph (especially in the next PR which is the optimizer)
BackendReporting moved to its own file
The io package no longer has a dependency on the backend/jvm package (!!!)
Cleanups of unnecessary parentheses etc.

There's a lot of extra cleanup that could be done, and that I'd like to do once the optimizer is in, since we have many "utility" classes that could be either a single class or split in a way that makes sense (e.g., AsmUtils is currently just about... logging). From what I understand some of this dates back to the porting of the JVM backend to Dotty, which introduced "temporary" interfaces to the rest of the compiler.

And more generally the overall state of the backend is spread across many classes that often touch what should be each other's internals (this is especially pronounced with the call graph, which will be added with the optimizer), and it's not easy to follow the data flow.

But that's for later.

SolalPirelli · 2026-02-04T14:57:52Z

compiler/src/dotty/tools/backend/jvm/BackendReporting.scala

+import dotty.tools.io.FileWriters.{BufferingReporter, Report}
+
+
+sealed trait BackendReporting {


Moved from PostProcessorFrontendAccess + added the code that was previously in the io package but really belongs here. No logic changes.

SolalPirelli · 2026-02-04T14:58:40Z

compiler/src/dotty/tools/backend/jvm/BackendUtils.scala

-  import frontendAccess.{compilerSettings}
-  import bTypes.*
-  import coreBTypes.jliLambdaMetaFactoryAltMetafactoryHandle
+class BackendUtils(val ppa: PostProcessorFrontendAccess, val ts: CoreBTypes)(using Context) {


This is the pattern that repeats in this PR: make dependencies explicit, and move some members as a result so classes can be layered instead of one big cyclic object graph.

SolalPirelli · 2026-02-04T15:00:12Z

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala


    import Primitives.TestOp

+    private object DesugaredSelect {


Only used in this class so moved from DottyBackendInterface. No logic changes.

SolalPirelli · 2026-02-04T15:01:28Z

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

-              genLoad(t, generatedType)
+          if (!sym.is(Package)) {
+            if (sym.is(Module)) genLoadModule(sym)
+            else locals.load(sym)


This was dead code, the Some branch was unreachable because we'd have matched a previous arm of the outer match.

SolalPirelli · 2026-02-04T15:02:11Z

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

      app match {
        case Apply(_, args) if app.symbol eq defn.newArrayMethod =>
-          val List(elemClaz, Literal(c: Constant), ArrayValue(_, dims)) = args: @unchecked
+          val List(elemClaz, Literal(c: Constant), av: tpd.JavaSeqLiteral) = args: @unchecked


ArrayValue was a complex extractor that wasn't actually needed in all but one case, so I inlined that case and simplified the rest.

SolalPirelli · 2026-02-04T15:02:27Z

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

    end emitLocalVarScopes

    def adapt(from: BType, to: BType): Unit = {
-      if (!from.conformsTo(to)) {


Porting a change made in scala2

SolalPirelli · 2026-02-04T15:03:41Z

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala


    private def emitArgument(av:   AnnotationVisitor,
                           name: String,
-                           arg:  Tree, bcodeStore: BCodeHelpers)(innerClasesStore: bcodeStore.BCInnerClassGen): Unit = {


No idea why this (instance!) method was taking itself as an extra argument, but the code works fine without it.

SolalPirelli · 2026-02-04T15:05:02Z

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

  private def compilingArray(using Context) =
    ctx.compilationUnit.source.file.name == "Array.scala"
+
+  private val primitiveCompilationUnits = Set(


This and below were moved from where they were declared because this class was their only use. We can/should centralize stuff like this as I wrote in the PR description, but that's for after adding the optimizer when we can have a full view of what utilities are needed...

SolalPirelli · 2026-02-04T15:06:04Z

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

+        .addFlagIf(sym.hasAnnotation(TransientAttr), ACC_TRANSIENT)
+        .addFlagIf(sym.hasAnnotation(VolatileAttr), ACC_VOLATILE)
+        .addFlagIf(!sym.is(Mutable), ACC_FINAL)
+    }


Used to be in BTypesFromSymbols for some reason.

SolalPirelli · 2026-02-04T15:07:37Z

compiler/src/dotty/tools/backend/jvm/BCodeUtils.scala

+
+object BCodeUtils {
+
+  /**


Used to be in BTypesFromSymbols but it's stateless and the optimizer needs it in other places.

SolalPirelli · 2026-02-04T15:08:16Z

compiler/src/dotty/tools/backend/jvm/BTypes.scala

 * This representation is immutable and independent of the compiler data structures, hence it can
 * be queried by concurrent threads.
 */
-abstract class BTypes { self =>


GitHub makes a mess of this diff because of the indentation changes but basically the class BTypes no longer exists, BType and its subtypes are top-level now.

SolalPirelli · 2026-02-04T15:09:14Z

compiler/src/dotty/tools/backend/jvm/CoreBTypes.scala

-  private lazy val _jliMethodHandleRef: Lazy[ClassBType] = perRunLazy(classBTypeFromSymbol(defn.MethodHandleClass))
+  def ObjectRef                   : ClassBType
+  def StringRef                   : ClassBType
+  def PredefRef                   : ClassBType


Added stuff the optimizer needs. I could revert here but it's very self-contained (decl here + impl in CoreBTypesFromSymbols)

SolalPirelli · 2026-02-04T15:09:29Z

compiler/src/dotty/tools/backend/jvm/CoreBTypes.scala

-   def typeOfArrayOp: Map[Int, BType]
-}
-
-abstract class CoreBTypesFromSymbols[I <: DottyBackendInterface] extends CoreBTypes {


Moved to its own file, no logic changes

SolalPirelli · 2026-02-04T15:10:28Z

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

  private val entryPoints = new mutable.HashSet[String]()
  def registerEntryPoint(s: String): Unit = entryPoints += s

-  private var _backendInterface: DottyBackendInterface = uninitialized


Messy diff but it's just moving the vars/defs around so they're in layering order

SolalPirelli · 2026-02-04T15:12:06Z

compiler/src/dotty/tools/backend/sjs/JSPrimitives.scala

-  override def getPrimitive(app: Apply, tpe: Type)(using Context): Int =
-    jsPrimitives.getOrElse(app.fun.symbol, super.getPrimitive(app, tpe))
+  override def getPrimitive(app: Apply, tpe: Type): Int =
+    jsPrimitives.getOrElse(app.fun.symbol(using ictx), super.getPrimitive(app, tpe))


Since I refactored this for consistency with other methods in DottyPrimitives I also had to refactor it here. Whether the JS backend should have a dependency on a class from the JVM backend is a question for another day.

SolalPirelli · 2026-02-04T15:13:03Z

compiler/src/dotty/tools/io/FileWriters.scala

 import java.util.ConcurrentModificationException

-/** !!!Copied from `dotty.tools.backend.jvm.ClassfileWriters` but no `PostProcessorFrontendAccess` needed.
- * this should probably be changed to wrap that class instead.


I'm pretty sure we don't want the io package wrapping the backend/jvm package. It should be the other way around.

SolalPirelli · 2026-02-04T15:17:27Z

compiler/src/dotty/tools/backend/jvm/BTypes.scala

-      res
-    }
-
-    private def firstCommonSuffix(as: List[ClassBType], bs: List[ClassBType]): ClassBType = {


One important change here, this method has specific expectations for the order and contents of its arguments, but one scala2 commit that touches the creation of said arguments had only been half backported so it could fail in some cases... thus I backported the other half of the commit, which is a change in this method.

SolalPirelli · 2026-02-04T15:19:17Z

compiler/src/dotty/tools/backend/jvm/BTypes.scala

-    final def isNonVoidPrimitiveType = isPrimitive && this != UNIT
-
-    final def isNullType             = this == srNullRef
-    final def isNothingType          = this == srNothingRef


Since these props depended on the current null/nothing/... refs, I made them abstract and ClassBType now takes a CoreBTypes to compare itself to them. I still think we're translating data back and forth between formats (symbols, classes, btypes) in sub-optimal ways but that's for later.

SolalPirelli added 7 commits February 4, 2026 11:03

Foundations for the optimizer

056c281

Revert settings changes

5c39f77

Dead code

8681e1a

Finish backporting of old commit that had been half backported

1e4f9d9

Remove unneeded prop causing weirdness

a383b5a

Fix compilingArray by using the right context

8e3a6ca

Minimize diffs

0e18a38

SolalPirelli changed the title ~~Foundations for the optimizer~~ Foundations for the optimizer & cleanup Feb 4, 2026

SolalPirelli commented Feb 4, 2026

View reviewed changes

Remove diff

783a336

SolalPirelli commented Feb 4, 2026

View reviewed changes

SolalPirelli mentioned this pull request Feb 4, 2026

Port the Scala2 optimizer #25165

Draft

SolalPirelli marked this pull request as ready for review February 5, 2026 08:43

		import dotty.tools.io.FileWriters.{BufferingReporter, Report}


		sealed trait BackendReporting {

Conversation

SolalPirelli commented Feb 4, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

SolalPirelli Feb 4, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

SolalPirelli commented Feb 4, 2026 •

edited

Loading

SolalPirelli Feb 4, 2026 •

edited

Loading