Alternative layout for IArray definition

Author: nicolasstucki

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -93,7 +93,8 @@ class Compiler {
          new FunctionXXLForwarders,  // Add forwarders for FunctionXXL apply method
          new ParamForwarding,        // Add forwarders for aliases of superclass parameters
          new TupleOptimizations,     // Optimize generic operations on tuples
-         new LetOverApply,            // Lift blocks from receivers of applications
+         new IArrayOptimizations,    // Optimize IArray operations
+         new LetOverApply,           // Lift blocks from receivers of applications
          new ArrayConstructors) ::   // Intercept creation of (non-generic) arrays and intrinsify.
     List(new Erasure) ::             // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
     List(new ElimErasedValueType,    // Expand erased value types to their underlying implmementation types

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -853,6 +853,9 @@ class Definitions {
     @tu lazy val CLP_parseRemainingArguments: Symbol = CommandLineParserModule.requiredMethod("parseRemainingArguments")
     @tu lazy val CLP_showError: Symbol = CommandLineParserModule.requiredMethod("showError")
 
+  @tu lazy val IArrayModule: Symbol = requiredModule("scala.IArray")
+  @tu lazy val IArrayModuleClass: Symbol = IArrayModule.moduleClass
+
   @tu lazy val TupleTypeRef: TypeRef = requiredClassRef("scala.Tuple")
   def TupleClass(using Context): ClassSymbol = TupleTypeRef.symbol.asClass
     @tu lazy val Tuple_cons: Symbol = TupleClass.requiredMethod("*:")

compiler/src/dotty/tools/dotc/transform/IArrayOptimizations.scala

@@ -0,0 +1,57 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Constants.Constant
+import Contexts._
+import Decorators._
+import Flags._
+import ast.Trees._
+import Definitions._
+import DenotTransformers._
+import StdNames._
+import Symbols._
+import MegaPhase._
+import Types._
+import dotty.tools.dotc.ast.tpd
+
+import scala.annotation.tailrec
+
+/** Optimize IArray operations */
+class IArrayOptimizations extends MiniPhase with IdentityDenotTransformer {
+  import tpd._
+
+  def phaseName: String = "iarrays"
+
+  override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree =
+    val sym = tree.symbol
+    if !sym.exists then tree
+    else if sym.owner == defn.IArrayModuleClass then
+      if sym.name == nme.apply then transformIArrayModuleApply(tree)
+      else tree
+    // TODO optimize IArrayClass apply and length
+    else
+      tree
+
+  /** Transform a call to `IArray.apply(...)` to `Array.apply(...).asInstanceOf[IArray[X]]` */
+  private def transformIArrayModuleApply(tree: tpd.Apply)(using Context): tpd.Tree =
+    tree.fun match
+      // Call to: def apply(x: X, xs: X*): IArray[X]
+      case fun: RefTree =>
+        ref(defn.ArrayModule).withSpan(fun.span)
+          .selectWithSig(tree.symbol)
+          .appliedToArgs(tree.args)
+          .asInstance(tree.tpe).withSpan(tree.span)
+      // Call to: def apply[T](xs: T*)(using ct: ClassTag[T]): IArray[T]
+      case Apply(tapp @ TypeApply(fun, targs), args1) =>
+        ref(defn.ArrayModule).withSpan(fun.span)
+          .selectWithSig(tree.symbol)
+          .appliedToTypeTrees(targs).withSpan(tapp.span)
+          .appliedToArgs(args1).withSpan(tree.fun.span)
+          .appliedToArgs(tree.args)
+          .asInstance(tree.tpe).withSpan(tree.span)
+      case _ =>
+        tree
+
+}
+

library/src/scala/IArray.scala

@@ -1,14 +1,12 @@
 package scala
 import reflect.ClassTag
 
+opaque type IArray[+T] = Array[_ <: T]
+
 /** An immutable array. An `IArray[T]` has the same representation as an `Array[T]`,
  *  but it cannot be updated. Unlike regular arrays, immutable arrays are covariant.
  */
-object opaques:
-  opaque type IArray[+T] = Array[_ <: T]
-
-  private[scala] type Sub[A] >: Array[A] <: IArray[A]
-  private[scala] type Sup[A] >: IArray[A] <: Array[_ <: A]
+object IArray:
 
   /** The selection operation on an immutable array.
     *
@@ -314,17 +312,6 @@ object opaques:
   given genericWrapUnitIArray(using DummyImplicit): Conversion[IArray[Unit], scala.collection.immutable.ArraySeq[Unit]] =
     arr => scala.collection.immutable.ArraySeq.ofUnit(arr.asInstanceOf[Array[Unit]])
 
-end opaques
-
-type IArray[+T] = opaques.IArray[T]
-
-object IArray {
-  import opaques.Sub
-  import opaques.Sup
-
-  // A convenience to avoid having to cast everything by hand
-  private given [A]: Conversion[Array[A], IArray[A]] = identity[Sub[A]]
-
   /** Convert an array into an immutable array without copying, the original array
    *   must _not_ be mutated after this or the guaranteed immutablity of IArray will
    *   be violated.
@@ -354,25 +341,25 @@ object IArray {
   def emptyObjectIArray: IArray[Object]  = Array.emptyObjectArray
 
   /** An immutable array with given elements. */
-  inline def apply[T](inline xs: T*)(using inline ct: ClassTag[T]): IArray[T] = Array(xs: _*).asInstanceOf
+  def apply[T](xs: T*)(using ct: ClassTag[T]): IArray[T] = Array(xs: _*).asInstanceOf
   /** An immutable array with given elements. */
-  inline def apply(inline x: Boolean, inline xs: Boolean*): IArray[Boolean] = Array(x, xs: _*).asInstanceOf
+  def apply(x: Boolean, xs: Boolean*): IArray[Boolean] = Array(x, xs: _*).asInstanceOf
   /** An immutable array with given elements. */
-  inline def apply(inline x: Byte, inline xs: Byte*): IArray[Byte] = Array(x, xs: _*).asInstanceOf
+  def apply(x: Byte, xs: Byte*): IArray[Byte] = Array(x, xs: _*).asInstanceOf
   /** An immutable array with given elements. */
-  inline def apply(inline x: Short, inline xs: Short*): IArray[Short] = Array(x, xs: _*).asInstanceOf
+  def apply(x: Short, xs: Short*): IArray[Short] = Array(x, xs: _*).asInstanceOf
   /** An immutable array with given elements. */
-  inline def apply(inline x: Char, inline xs: Char*): IArray[Char] = Array(x, xs: _*).asInstanceOf
+  def apply(x: Char, xs: Char*): IArray[Char] = Array(x, xs: _*).asInstanceOf
   /** An immutable array with given elements. */
-  inline def apply(inline x: Int, inline xs: Int*): IArray[Int] = Array(x, xs: _*).asInstanceOf
+  def apply(x: Int, xs: Int*): IArray[Int] = Array(x, xs: _*).asInstanceOf
   /** An immutable array with given elements. */
-  inline def apply(inline x: Long, inline xs: Long*): IArray[Long] = Array(x, xs: _*).asInstanceOf
+  def apply(x: Long, xs: Long*): IArray[Long] = Array(x, xs: _*).asInstanceOf
   /** An immutable array with given elements. */
-  inline def apply(inline x: Float, inline xs: Float*): IArray[Float] = Array(x, xs: _*).asInstanceOf
+  def apply(x: Float, xs: Float*): IArray[Float] = Array(x, xs: _*).asInstanceOf
   /** An immutable array with given elements. */
-  inline def apply(inline x: Double, inline xs: Double*): IArray[Double] = Array(x, xs: _*).asInstanceOf
+  def apply(x: Double, xs: Double*): IArray[Double] = Array(x, xs: _*).asInstanceOf
   /** An immutable array with given elements. */
-  inline def apply(inline x: Unit, inline xs: Unit*): IArray[Unit] = Array(x, xs: _*).asInstanceOf
+  def apply(x: Unit, xs: Unit*): IArray[Unit] = Array(x, xs: _*).asInstanceOf
 
   /** Concatenates all arrays into a single immutable array.
    *
@@ -529,8 +516,7 @@ object IArray {
    *  @param x the selector value
    *  @return  sequence wrapped in a [[scala.Some]], if `x` is a Seq, otherwise `None`
    */
-   def unapplySeq[T](x: IArray[T]) =
-    // The double type ascription is currently needed,
-    // for some reason (see: https://scastie.scala-lang.org/sSsmOhKxSKym405MgNRKqQ)
-    Array.unapplySeq((x: Sup[T]): Array[_ <: T])
-}
+  def unapplySeq[T](x: IArray[T]): Array.UnapplySeqWrapper[_ <: T] =
+    Array.unapplySeq(x)
+
+end IArray