Initial pre-change cleanups

Author: dwijnand

Diff for: compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -535,17 +535,18 @@ class Definitions {
       List(AnyType), EmptyScope)
   @tu lazy val SingletonType: TypeRef = SingletonClass.typeRef
 
-  @tu lazy val CollectionSeqType: TypeRef = requiredClassRef("scala.collection.Seq")
-  @tu lazy val SeqType: TypeRef = requiredClassRef("scala.collection.immutable.Seq")
+  @tu lazy val CollectionSeqType: TypeRef  = requiredClassRef("scala.collection.Seq")
+  @tu lazy val SeqType: TypeRef            = requiredClassRef("scala.collection.immutable.Seq")
+  @tu lazy val SeqModule: Symbol           = requiredModule("scala.collection.immutable.Seq")
+  @tu lazy val SeqModule_apply: Symbol     = SeqModule.requiredMethod(nme.apply)
+  def SeqModuleAlias: Symbol               = ScalaPackageClass.requiredMethod(nme.Seq)
   def SeqClass(using Context): ClassSymbol = SeqType.symbol.asClass
     @tu lazy val Seq_apply        : Symbol = SeqClass.requiredMethod(nme.apply)
     @tu lazy val Seq_head         : Symbol = SeqClass.requiredMethod(nme.head)
     @tu lazy val Seq_drop         : Symbol = SeqClass.requiredMethod(nme.drop)
     @tu lazy val Seq_lengthCompare: Symbol = SeqClass.requiredMethod(nme.lengthCompare, List(IntType))
     @tu lazy val Seq_length       : Symbol = SeqClass.requiredMethod(nme.length)
     @tu lazy val Seq_toSeq        : Symbol = SeqClass.requiredMethod(nme.toSeq)
-    @tu lazy val SeqModule        : Symbol = requiredModule("scala.collection.immutable.Seq")
-    @tu lazy val SeqModule_apply  : Symbol = SeqModule.requiredMethod(nme.apply)
 
 
   @tu lazy val StringOps: Symbol = requiredClass("scala.collection.StringOps")

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

@@ -1,15 +1,11 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package transform
 
-import core.*
+import ast.tpd
+import core.*, Contexts.*, Decorators.*, Symbols.*, Flags.*, StdNames.*
+import reporting.trace
 import MegaPhase.*
-import Contexts.*
-import Symbols.*
-import Flags.*
-import StdNames.*
-import dotty.tools.dotc.ast.tpd
-
-
 
 /** This phase rewrites calls to `Array.apply` to a direct instantiation of the array in the bytecode.
  *
@@ -22,37 +18,30 @@ class ArrayApply extends MiniPhase {
 
   override def description: String = ArrayApply.description
 
-  private var transformListApplyLimit = 8
-
-  private def reducingTransformListApply[A](depth: Int)(body: => A): A = {
-      val saved = transformListApplyLimit
-      transformListApplyLimit -= depth
-      try body
-      finally transformListApplyLimit = saved
-    }
+  private val transformListApplyLimit = 8
 
-  override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree =
+  override def transformApply(tree: Apply)(using Context): Tree =
     if isArrayModuleApply(tree.symbol) then
       tree.args match
-        case StripAscription(Apply(wrapRefArrayMeth, (seqLit: tpd.JavaSeqLiteral) :: Nil)) :: ct :: Nil
+        case StripAscription(Apply(wrapRefArrayMeth, (seqLit: JavaSeqLiteral) :: Nil)) :: ct :: Nil
             if defn.WrapArrayMethods().contains(wrapRefArrayMeth.symbol) && elideClassTag(ct) =>
           seqLit
 
-        case elem0 :: StripAscription(Apply(wrapRefArrayMeth, (seqLit: tpd.JavaSeqLiteral) :: Nil)) :: Nil
+        case elem0 :: StripAscription(Apply(wrapRefArrayMeth, (seqLit: JavaSeqLiteral) :: Nil)) :: Nil
             if defn.WrapArrayMethods().contains(wrapRefArrayMeth.symbol) =>
-          tpd.JavaSeqLiteral(elem0 :: seqLit.elems, seqLit.elemtpt)
+          JavaSeqLiteral(elem0 :: seqLit.elems, seqLit.elemtpt)
 
         case _ =>
           tree
 
     else if isListOrSeqModuleApply(tree.symbol) then
       tree.args match
         // <List or Seq>(a, b, c) ~> new ::(a, new ::(b, new ::(c, Nil))) but only for reference types
-        case StripAscription(Apply(wrapArrayMeth, List(StripAscription(rest: tpd.JavaSeqLiteral)))) :: Nil
+        case StripAscription(Apply(wrapArrayMeth, List(StripAscription(rest: JavaSeqLiteral)))) :: Nil
           if defn.WrapArrayMethods().contains(wrapArrayMeth.symbol) &&
             rest.elems.lengthIs < transformListApplyLimit =>
-          rest.elems.foldRight(tpd.ref(defn.NilModule)): (elem, acc) => 
-            tpd.New(defn.ConsType, List(elem.ensureConforms(defn.ObjectType), acc))
+          rest.elems.foldRight(ref(defn.NilModule)): (elem, acc) => 
+            New(defn.ConsType, List(elem.ensureConforms(defn.ObjectType), acc))
 
         case _ =>
           tree