use .to(ArraySeq) instead of .toArray, fixing some deprecations (#365)

The .toArray method converts an iterable to an Array. However,
this is a minimal Java-esque array and does not support any of Scala's
interfaces. Where an interface like Iterable or Seq was needed, this
would require a coercion from Array to ArraySeq, which the compiler
tells us would incur an additional copy.

This fixes the deprecation warning by using converting directly to
ArraySeq, avoiding the implicit coercion and additional copy.

Author: katrinafyi

build.sc

@@ -9,7 +9,7 @@ import contrib.scalapblib._
 object basil extends RootModule with ScalaModule with antlr.AntlrModule with ScalaPBModule {
   def scalaVersion = "3.3.4"
 
-  // def scalacOptions: T[Seq[String]] = Seq("-Xprint:typer")
+  def scalacOptions: T[Seq[String]] = Seq("-deprecation")
 
   val javaTests = ivy"com.novocode:junit-interface:0.11"
   val scalaTests = ivy"org.scalatest::scalatest:3.2.19"

src/main/scala/ir/dsl/DSL.scala

@@ -190,7 +190,7 @@ def ret(params: (String, Expr)*): EventuallyReturn = EventuallyReturn(params)
 def unreachable: EventuallyUnreachable = EventuallyUnreachable()
 
 def directCall(lhs: Iterable[(String, Variable)], tgt: String, actualParams: (String, Expr)*): EventuallyCall =
-  EventuallyCall(DelayNameResolve(tgt), lhs.toArray, actualParams)
+  EventuallyCall(DelayNameResolve(tgt), lhs.to(ArraySeq), actualParams)
 
 def directCall(tgt: String): EventuallyCall = directCall(Nil, tgt)
 

src/main/scala/ir/dsl/IRToDSL.scala

@@ -1,6 +1,6 @@
 package ir.dsl
 
-import scala.collection.immutable.SortedMap
+import scala.collection.immutable.{SortedMap, ArraySeq}
 import ir.*
 
 /**
@@ -20,7 +20,7 @@ object IRToDSL {
 
   def convertJump(x: Jump): EventuallyJump = x match {
     case Unreachable(label) => EventuallyUnreachable(label)
-    case Return(label, out) => EventuallyReturn(out.map(keyToString).toArray, label)
+    case Return(label, out) => EventuallyReturn(out.map(keyToString).to(ArraySeq), label)
     case GoTo(targs, label) => EventuallyGoto(targs.map(t => DelayNameResolve(t.label)).toList, label)
   }
 
@@ -29,7 +29,7 @@ object IRToDSL {
   def convertCallStatement(x: Call): EventuallyStatement = x match {
     case DirectCall(targ, outs, actuals, label) =>
       // XXX: be aware of ordering, .map() on a SortedMap may return a HashMap.
-      directCall(outs.toArray.map(keyToString), targ.name, actuals.toArray.map(keyToString): _*)
+      directCall(outs.to(ArraySeq).map(keyToString), targ.name, actuals.to(ArraySeq).map(keyToString): _*)
     case IndirectCall(targ, label) => indirectCall(targ)
   }
 
@@ -39,21 +39,21 @@ object IRToDSL {
   }
 
   def convertBlock(x: Block) =
-    EventuallyBlock(x.label, x.statements.toArray.map(convertStatement), convertJump(x.jump), x.address)
+    EventuallyBlock(x.label, x.statements.to(ArraySeq).map(convertStatement), convertJump(x.jump), x.address)
 
   def convertProcedure(x: Procedure) =
     EventuallyProcedure(
       x.procName,
       x.formalInParam.toSeq.map(localVarToTuple).to(SortedMap),
       x.formalOutParam.toSeq.map(localVarToTuple).to(SortedMap),
-      x.blocks.map(convertBlock).toArray,
+      x.blocks.map(convertBlock).to(ArraySeq),
       x.entryBlock.map(_.label),
       x.returnBlock.map(_.label),
       x.address
     )
 
   def convertProgram(x: Program) =
     val others = x.procedures.filter(_ != x.mainProcedure).map(convertProcedure)
-    EventuallyProgram(convertProcedure(x.mainProcedure), others.toArray, x.initialMemory.values)
+    EventuallyProgram(convertProcedure(x.mainProcedure), others.to(ArraySeq), x.initialMemory.values)
 
 }

src/main/scala/ir/transforms/Inline.scala

@@ -6,6 +6,7 @@ import ir.dsl.IRToDSL.*
 import ir.dsl.*
 
 import scala.collection.mutable
+import scala.collection.immutable.{ArraySeq}
 
 object Counter {
   var id = 0
@@ -64,9 +65,11 @@ def convertJumpRenaming(blockName: String => String, varName: CILVisitor, x: Jum
   case Unreachable(label) => EventuallyUnreachable(label)
   case Return(label, out) =>
     EventuallyReturn(
-      out.toList.map { case (v: Variable, e: Expr) =>
-        ((v.name, visit_expr(varName, e)))
-      }.toArray,
+      out.toList
+        .map { case (v: Variable, e: Expr) =>
+          ((v.name, visit_expr(varName, e)))
+        }
+        .to(ArraySeq),
       label
     )
 }
@@ -77,9 +80,9 @@ def keyToString[T](varRenamer: CILVisitor)(x: (Variable, Expr)): (String, Expr)
 def convertStatementRenaming(varRenamer: CILVisitor)(x: Statement): EventuallyStatement = x match {
   case DirectCall(targ, outs, actuals, label) =>
     directCall(
-      outs.toArray.map(v => (v(0).name, visit_rvar(varRenamer, v(1)))),
+      outs.to(ArraySeq).map(v => (v(0).name, visit_rvar(varRenamer, v(1)))),
       targ.name,
-      actuals.toArray.map(keyToString(varRenamer)): _*
+      actuals.to(ArraySeq).map(keyToString(varRenamer)): _*
     )
   case IndirectCall(targ, label) => indirectCall(visit_rvar(varRenamer, targ))
   case x: NonCallStatement =>
@@ -89,7 +92,7 @@ def convertStatementRenaming(varRenamer: CILVisitor)(x: Statement): EventuallySt
 def convertBlockRenaming(varRenamer: CILVisitor, blockName: String => String)(x: Block) = {
   EventuallyBlock(
     blockName(x.label),
-    x.statements.toArray.map(convertStatementRenaming(varRenamer)),
+    x.statements.to(ArraySeq).map(convertStatementRenaming(varRenamer)),
     convertJumpRenaming(blockName, varRenamer, x.jump),
     x.address
   )
@@ -98,7 +101,7 @@ def convertBlockRenaming(varRenamer: CILVisitor, blockName: String => String)(x:
 /**
   * Inline a procedure call to the calling procedure;
   *
-  * - maintains param form 
+  * - maintains param form
   * - maintain dsa form if both procedures are in dsa form
   *
   * require invariant.SingleCallBlockEnd