Import JavaOpt / ScalacOpt from Scala CLI

Author: alexarchambault

directive-handler/src/main/scala/scala/cli/directivehandler/JavaOpt.scala

@@ -0,0 +1,32 @@
+package scala.cli.directivehandler
+
+final case class JavaOpt(value: String) {
+  def key: Option[String] =
+    JavaOpt.optionPrefixes.find(value.startsWith)
+      .orElse {
+        if (value.startsWith("-"))
+          Some(value.takeWhile(_ != ':'))
+            .filterNot(key => JavaOpt.repeatingKeys.exists(_.startsWith(key)))
+        else if (value.startsWith("@")) Some("@")
+        else None
+      }
+}
+
+object JavaOpt {
+  private val repeatingKeys = Set(
+    "--add-exports",
+    "--add-modules",
+    "--add-opens",
+    "--add-reads",
+    "--patch-module"
+  )
+
+  /* Hardcoded prefixes for java options */
+  private val optionPrefixes = Set("-Xmn", "-Xms", "-Xmx", "-Xss")
+
+  implicit val keyOf: ShadowingSeq.KeyOf[JavaOpt] =
+    ShadowingSeq.KeyOf(
+      _.key,
+      seq => ScalacOpt.groupCliOptions(seq.map(_.value))
+    )
+}

directive-handler/src/main/scala/scala/cli/directivehandler/Positioned.scala

@@ -40,4 +40,12 @@ object Positioned {
 
   implicit def ordering[T](implicit underlying: Ordering[T]): Ordering[Positioned[T]] =
     Ordering.by(_.value)
+
+  implicit def keyOf[T](implicit
+    underlying: ShadowingSeq.KeyOf[T]
+  ): ShadowingSeq.KeyOf[Positioned[T]] =
+    ShadowingSeq.KeyOf(
+      p => underlying.get(p.value),
+      seq => underlying.groups(seq.map(_.value))
+    )
 }

directive-handler/src/main/scala/scala/cli/directivehandler/ScalacOpt.scala

@@ -0,0 +1,34 @@
+package scala.cli.directivehandler
+
+final case class ScalacOpt(value: String) {
+  def key: Option[String] =
+    if (value.startsWith("-"))
+      Some(value.takeWhile(_ != ':'))
+        .filterNot(key => ScalacOpt.repeatingKeys.exists(_.startsWith(key)))
+    else if (value.startsWith("@"))
+      Some("@")
+    else
+      None
+}
+
+object ScalacOpt {
+  private val repeatingKeys = Set(
+    "-Xplugin:",
+    "-P" // plugin options
+  )
+
+  implicit val keyOf: ShadowingSeq.KeyOf[ScalacOpt] =
+    ShadowingSeq.KeyOf(
+      _.key,
+      seq => groupCliOptions(seq.map(_.value))
+    )
+
+  // Groups options (starting with `-` or `@`) with option arguments that follow
+  def groupCliOptions(opts: Seq[String]): Seq[Int] =
+    opts
+      .zipWithIndex
+      .collect {
+        case (opt, idx) if opt.startsWith("-") || opt.startsWith("@") =>
+          idx
+      }
+}

directive-handler/src/main/scala/scala/cli/directivehandler/ShadowingSeq.scala

@@ -0,0 +1,86 @@
+package scala.cli.directivehandler
+
+import dependency.AnyDependency
+
+import scala.collection.mutable
+
+/** Seq ensuring some of its values are unique according to some key */
+final case class ShadowingSeq[T] private (values: Seq[Seq[T]]) {
+  lazy val toSeq: Seq[T] = values.flatten
+  def map[U](f: T => U)(implicit key: ShadowingSeq.KeyOf[U]): ShadowingSeq[U] =
+    ShadowingSeq.empty[U] ++ toSeq.map(f)
+  def mapSubSeq[U](f: Seq[T] => Seq[U]): ShadowingSeq[U] =
+    ShadowingSeq[U](values.map(f))
+  def filter(f: T => Boolean)(implicit key: ShadowingSeq.KeyOf[T]): ShadowingSeq[T] =
+    ShadowingSeq.empty ++ toSeq.filter(f)
+  def filterSubSeq(f: Seq[T] => Boolean): ShadowingSeq[T] =
+    ShadowingSeq(values.filter(f))
+  def filterKeys(f: T => Boolean): ShadowingSeq[T] =
+    filterSubSeq {
+      case Seq(head, _*) => f(head)
+      case _             => true
+    }
+  def keys: Seq[T] = values.map(_.head)
+  def ++(other: Seq[T])(implicit key: ShadowingSeq.KeyOf[T]): ShadowingSeq[T] =
+    addGroups(ShadowingSeq.groups(other, key.groups(other)))
+  private def addGroups(other: Seq[Seq[T]])(implicit key: ShadowingSeq.KeyOf[T]): ShadowingSeq[T] =
+    if (other.isEmpty) this
+    else {
+      val l    = new mutable.ListBuffer[Seq[T]]
+      val seen = new mutable.HashSet[String]
+
+      for (group <- values.iterator ++ other.iterator) {
+        assert(group.nonEmpty)
+        val keyOpt = key.get(group.head)
+        if (!keyOpt.exists(seen.contains)) {
+          l += group
+          for (key <- keyOpt)
+            seen += key
+        }
+      }
+
+      ShadowingSeq(l.toList)
+    }
+  def keyValueMap: Map[T, Seq[T]] =
+    values
+      .flatMap {
+        case Seq(head, tail @ _*) => Some(head -> tail)
+        case _                    => None
+      }
+      .toMap
+
+  def get(key: T): Seq[T] =
+    keyValueMap
+      .get(key)
+      .toSeq.flatten
+}
+
+object ShadowingSeq {
+
+  final case class KeyOf[T](
+    get: T => Option[String],
+    /** The indices at which sub-groups of values start */
+    groups: Seq[T] => Seq[Int]
+  )
+  object KeyOf {
+    implicit val keyOfAnyDependency: KeyOf[AnyDependency] =
+      KeyOf(dep => Some(dep.module.render), _.indices)
+  }
+
+  def empty[T]: ShadowingSeq[T] = ShadowingSeq(Nil)
+
+  def from[T](values: Seq[T])(implicit key: KeyOf[T]): ShadowingSeq[T] =
+    empty[T] ++ values
+
+  private def groups[T](values: Seq[T], indices: Seq[Int]): Seq[Seq[T]] = {
+    val safeIndices = Seq(0) ++ indices ++ Seq(values.length)
+    safeIndices
+      .sliding(2)
+      .map {
+        case Seq(start, end) =>
+          values.slice(start, end)
+      }
+      .filter(_.nonEmpty)
+      .toVector
+  }
+}