Subsume platform cross building

Problem In sbt 1, platform cross building is implemented using in the user-land using `%%%` operator, which clevery handles both Scala cross building and appending platform suffix like sjs1. However, in general symbolic `%%%` is confusing, and hard to explain. Solution In sbt 2, we should subsume the idea of platform cross building, so `%%` can act as the current `%%%` operator. This adds a new field called `platformOpt` to `ModuleID`, which by default will be set to `None`. `ScalaModuleInfo` will also add a new field called `platform`, which can be set to `None`, `Some(sjs1)` etc. As part of module transformation (like adding `_2.13`), the library management engine can transform `ModuleID` to `sjs1` etc. `("com.github.scopt" %% "scopt" % "4.1.0").platform(jvm)` will explicitly use the JVM version of dependency (equivalent to today's `%%`).
2023-03-12 00:01:32 -05:00 · 2023-03-12 00:01:32 -05:00 · 47ef80eadf
parent f0c54a9fe9
commit 47ef80eadf
10 changed files with 150 additions and 26 deletions
--- a/core/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala
+++ b/core/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala
@ -17,22 +17,24 @@ final class ModuleID private (
  val exclusions: Vector[sbt.librarymanagement.InclExclRule],
  val extraAttributes: Map[String, String],
  val crossVersion: sbt.librarymanagement.CrossVersion,
-  val branchName: Option[String]) extends sbt.librarymanagement.ModuleIDExtra with Serializable {
+  val branchName: Option[String],
+  val platformOpt: Option[String]) extends sbt.librarymanagement.ModuleIDExtra with Serializable {
  
-  private def this(organization: String, name: String, revision: String) = this(organization, name, revision, None, false, true, false, Vector.empty, Vector.empty, Vector.empty, Map.empty, sbt.librarymanagement.Disabled(), None)
+  private def this(organization: String, name: String, revision: String) = this(organization, name, revision, None, false, true, false, Vector.empty, Vector.empty, Vector.empty, Map.empty, sbt.librarymanagement.Disabled(), None, None)
+  private def this(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean, isForce: Boolean, explicitArtifacts: Vector[sbt.librarymanagement.Artifact], inclusions: Vector[sbt.librarymanagement.InclExclRule], exclusions: Vector[sbt.librarymanagement.InclExclRule], extraAttributes: Map[String, String], crossVersion: sbt.librarymanagement.CrossVersion, branchName: Option[String]) = this(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName, None)
  
  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
-    case x: ModuleID => (this.organization == x.organization) && (this.name == x.name) && (this.revision == x.revision) && (this.configurations == x.configurations) && (this.isChanging == x.isChanging) && (this.isTransitive == x.isTransitive) && (this.isForce == x.isForce) && (this.explicitArtifacts == x.explicitArtifacts) && (this.inclusions == x.inclusions) && (this.exclusions == x.exclusions) && (this.extraAttributes == x.extraAttributes) && (this.crossVersion == x.crossVersion) && (this.branchName == x.branchName)
+    case x: ModuleID => (this.organization == x.organization) && (this.name == x.name) && (this.revision == x.revision) && (this.configurations == x.configurations) && (this.isChanging == x.isChanging) && (this.isTransitive == x.isTransitive) && (this.isForce == x.isForce) && (this.explicitArtifacts == x.explicitArtifacts) && (this.inclusions == x.inclusions) && (this.exclusions == x.exclusions) && (this.extraAttributes == x.extraAttributes) && (this.crossVersion == x.crossVersion) && (this.branchName == x.branchName) && (this.platformOpt == x.platformOpt)
    case _ => false
  })
  override def hashCode: Int = {
-    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ModuleID".##) + organization.##) + name.##) + revision.##) + configurations.##) + isChanging.##) + isTransitive.##) + isForce.##) + explicitArtifacts.##) + inclusions.##) + exclusions.##) + extraAttributes.##) + crossVersion.##) + branchName.##)
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ModuleID".##) + organization.##) + name.##) + revision.##) + configurations.##) + isChanging.##) + isTransitive.##) + isForce.##) + explicitArtifacts.##) + inclusions.##) + exclusions.##) + extraAttributes.##) + crossVersion.##) + branchName.##) + platformOpt.##)
  }
  override def toString: String = {
    this.toStringImpl
  }
-  private[this] def copy(organization: String = organization, name: String = name, revision: String = revision, configurations: Option[String] = configurations, isChanging: Boolean = isChanging, isTransitive: Boolean = isTransitive, isForce: Boolean = isForce, explicitArtifacts: Vector[sbt.librarymanagement.Artifact] = explicitArtifacts, inclusions: Vector[sbt.librarymanagement.InclExclRule] = inclusions, exclusions: Vector[sbt.librarymanagement.InclExclRule] = exclusions, extraAttributes: Map[String, String] = extraAttributes, crossVersion: sbt.librarymanagement.CrossVersion = crossVersion, branchName: Option[String] = branchName): ModuleID = {
-    new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName)
+  private[this] def copy(organization: String = organization, name: String = name, revision: String = revision, configurations: Option[String] = configurations, isChanging: Boolean = isChanging, isTransitive: Boolean = isTransitive, isForce: Boolean = isForce, explicitArtifacts: Vector[sbt.librarymanagement.Artifact] = explicitArtifacts, inclusions: Vector[sbt.librarymanagement.InclExclRule] = inclusions, exclusions: Vector[sbt.librarymanagement.InclExclRule] = exclusions, extraAttributes: Map[String, String] = extraAttributes, crossVersion: sbt.librarymanagement.CrossVersion = crossVersion, branchName: Option[String] = branchName, platformOpt: Option[String] = platformOpt): ModuleID = {
+    new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName, platformOpt)
  }
  def withOrganization(organization: String): ModuleID = {
    copy(organization = organization)
@ -73,9 +75,13 @@ final class ModuleID private (
  def withBranchName(branchName: Option[String]): ModuleID = {
    copy(branchName = branchName)
  }
+  def withPlatformOpt(platformOpt: Option[String]): ModuleID = {
+    copy(platformOpt = platformOpt)
+  }
 }
 object ModuleID extends sbt.librarymanagement.ModuleIDFunctions {
  
  def apply(organization: String, name: String, revision: String): ModuleID = new ModuleID(organization, name, revision)
  def apply(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean, isForce: Boolean, explicitArtifacts: Vector[sbt.librarymanagement.Artifact], inclusions: Vector[sbt.librarymanagement.InclExclRule], exclusions: Vector[sbt.librarymanagement.InclExclRule], extraAttributes: Map[String, String], crossVersion: sbt.librarymanagement.CrossVersion, branchName: Option[String]): ModuleID = new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName)
+  def apply(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean, isForce: Boolean, explicitArtifacts: Vector[sbt.librarymanagement.Artifact], inclusions: Vector[sbt.librarymanagement.InclExclRule], exclusions: Vector[sbt.librarymanagement.InclExclRule], extraAttributes: Map[String, String], crossVersion: sbt.librarymanagement.CrossVersion, branchName: Option[String], platformOpt: Option[String]): ModuleID = new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName, platformOpt)
 }
--- a/core/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala
+++ b/core/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala
@ -24,8 +24,9 @@ implicit lazy val ModuleIDFormat: JsonFormat[sbt.librarymanagement.ModuleID] = n
      val extraAttributes = unbuilder.readField[Map[String, String]]("extraAttributes")
      val crossVersion = unbuilder.readField[sbt.librarymanagement.CrossVersion]("crossVersion")
      val branchName = unbuilder.readField[Option[String]]("branchName")
+      val platformOpt = unbuilder.readField[Option[String]]("platformOpt")
      unbuilder.endObject()
-      sbt.librarymanagement.ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName)
+      sbt.librarymanagement.ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName, platformOpt)
      case None =>
      deserializationError("Expected JsObject but found None")
    }
@ -45,6 +46,7 @@ implicit lazy val ModuleIDFormat: JsonFormat[sbt.librarymanagement.ModuleID] = n
    builder.addField("extraAttributes", obj.extraAttributes)
    builder.addField("crossVersion", obj.crossVersion)
    builder.addField("branchName", obj.branchName)
+    builder.addField("platformOpt", obj.platformOpt)
    builder.endObject()
  }
 }
--- a/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfo.scala
+++ b/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfo.scala
@ -12,22 +12,24 @@ final class ScalaModuleInfo private (
  val filterImplicit: Boolean,
  val overrideScalaVersion: Boolean,
  val scalaOrganization: String,
-  val scalaArtifacts: scala.Vector[String]) extends Serializable {
+  val scalaArtifacts: scala.Vector[String],
+  val platform: Option[String]) extends Serializable {
  
-  private def this(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean) = this(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, sbt.librarymanagement.ScalaArtifacts.Organization, sbt.librarymanagement.ScalaArtifacts.Artifacts)
+  private def this(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean) = this(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, sbt.librarymanagement.ScalaArtifacts.Organization, sbt.librarymanagement.ScalaArtifacts.Artifacts, None)
+  private def this(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean, scalaOrganization: String, scalaArtifacts: scala.Vector[String]) = this(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts, None)
  
  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
-    case x: ScalaModuleInfo => (this.scalaFullVersion == x.scalaFullVersion) && (this.scalaBinaryVersion == x.scalaBinaryVersion) && (this.configurations == x.configurations) && (this.checkExplicit == x.checkExplicit) && (this.filterImplicit == x.filterImplicit) && (this.overrideScalaVersion == x.overrideScalaVersion) && (this.scalaOrganization == x.scalaOrganization) && (this.scalaArtifacts == x.scalaArtifacts)
+    case x: ScalaModuleInfo => (this.scalaFullVersion == x.scalaFullVersion) && (this.scalaBinaryVersion == x.scalaBinaryVersion) && (this.configurations == x.configurations) && (this.checkExplicit == x.checkExplicit) && (this.filterImplicit == x.filterImplicit) && (this.overrideScalaVersion == x.overrideScalaVersion) && (this.scalaOrganization == x.scalaOrganization) && (this.scalaArtifacts == x.scalaArtifacts) && (this.platform == x.platform)
    case _ => false
  })
  override def hashCode: Int = {
-    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ScalaModuleInfo".##) + scalaFullVersion.##) + scalaBinaryVersion.##) + configurations.##) + checkExplicit.##) + filterImplicit.##) + overrideScalaVersion.##) + scalaOrganization.##) + scalaArtifacts.##)
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ScalaModuleInfo".##) + scalaFullVersion.##) + scalaBinaryVersion.##) + configurations.##) + checkExplicit.##) + filterImplicit.##) + overrideScalaVersion.##) + scalaOrganization.##) + scalaArtifacts.##) + platform.##)
  }
  override def toString: String = {
-    "ScalaModuleInfo(" + scalaFullVersion + ", " + scalaBinaryVersion + ", " + configurations + ", " + checkExplicit + ", " + filterImplicit + ", " + overrideScalaVersion + ", " + scalaOrganization + ", " + scalaArtifacts + ")"
+    "ScalaModuleInfo(" + scalaFullVersion + ", " + scalaBinaryVersion + ", " + configurations + ", " + checkExplicit + ", " + filterImplicit + ", " + overrideScalaVersion + ", " + scalaOrganization + ", " + scalaArtifacts + ", " + platform + ")"
  }
-  private[this] def copy(scalaFullVersion: String = scalaFullVersion, scalaBinaryVersion: String = scalaBinaryVersion, configurations: Vector[sbt.librarymanagement.Configuration] = configurations, checkExplicit: Boolean = checkExplicit, filterImplicit: Boolean = filterImplicit, overrideScalaVersion: Boolean = overrideScalaVersion, scalaOrganization: String = scalaOrganization, scalaArtifacts: scala.Vector[String] = scalaArtifacts): ScalaModuleInfo = {
-    new ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts)
+  private[this] def copy(scalaFullVersion: String = scalaFullVersion, scalaBinaryVersion: String = scalaBinaryVersion, configurations: Vector[sbt.librarymanagement.Configuration] = configurations, checkExplicit: Boolean = checkExplicit, filterImplicit: Boolean = filterImplicit, overrideScalaVersion: Boolean = overrideScalaVersion, scalaOrganization: String = scalaOrganization, scalaArtifacts: scala.Vector[String] = scalaArtifacts, platform: Option[String] = platform): ScalaModuleInfo = {
+    new ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts, platform)
  }
  def withScalaFullVersion(scalaFullVersion: String): ScalaModuleInfo = {
    copy(scalaFullVersion = scalaFullVersion)
@ -53,9 +55,13 @@ final class ScalaModuleInfo private (
  def withScalaArtifacts(scalaArtifacts: scala.Vector[String]): ScalaModuleInfo = {
    copy(scalaArtifacts = scalaArtifacts)
  }
+  def withPlatform(platform: Option[String]): ScalaModuleInfo = {
+    copy(platform = platform)
+  }
 }
 object ScalaModuleInfo {
  
  def apply(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean): ScalaModuleInfo = new ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion)
  def apply(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean, scalaOrganization: String, scalaArtifacts: scala.Vector[String]): ScalaModuleInfo = new ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts)
+  def apply(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean, scalaOrganization: String, scalaArtifacts: scala.Vector[String], platform: Option[String]): ScalaModuleInfo = new ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts, platform)
 }
--- a/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfoFormats.scala
+++ b/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfoFormats.scala
@ -19,8 +19,9 @@ implicit lazy val ScalaModuleInfoFormat: JsonFormat[sbt.librarymanagement.ScalaM
      val overrideScalaVersion = unbuilder.readField[Boolean]("overrideScalaVersion")
      val scalaOrganization = unbuilder.readField[String]("scalaOrganization")
      val scalaArtifacts = unbuilder.readField[scala.Vector[String]]("scalaArtifacts")
+      val platform = unbuilder.readField[Option[String]]("platform")
      unbuilder.endObject()
-      sbt.librarymanagement.ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts)
+      sbt.librarymanagement.ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts, platform)
      case None =>
      deserializationError("Expected JsObject but found None")
    }
@ -35,6 +36,7 @@ implicit lazy val ScalaModuleInfoFormat: JsonFormat[sbt.librarymanagement.ScalaM
    builder.addField("overrideScalaVersion", obj.overrideScalaVersion)
    builder.addField("scalaOrganization", obj.scalaOrganization)
    builder.addField("scalaArtifacts", obj.scalaArtifacts)
+    builder.addField("platform", obj.platform)
    builder.endObject()
  }
 }
--- a/core/src/main/contraband/librarymanagement.json
+++ b/core/src/main/contraband/librarymanagement.json
@ -294,7 +294,13 @@
        { "name": "filterImplicit",       "type": "boolean"                                                                                                },
        { "name": "overrideScalaVersion", "type": "boolean"                                                                                                },
        { "name": "scalaOrganization",    "type": "String",               "default": "sbt.librarymanagement.ScalaArtifacts.Organization", "since": "0.0.1" },
-        { "name": "scalaArtifacts",       "type": "scala.Vector[String]", "default": "sbt.librarymanagement.ScalaArtifacts.Artifacts",    "since": "0.0.1" }
+        { "name": "scalaArtifacts",       "type": "scala.Vector[String]", "default": "sbt.librarymanagement.ScalaArtifacts.Artifacts",    "since": "0.0.1" },
+        {
+          "name": "platform",
+          "type": "Option[String]",
+          "default": "None",
+          "since": "2.0.0"
+        }
      ]
    },
    {
@ -332,7 +338,8 @@
        { "name": "exclusions",        "type": "sbt.librarymanagement.InclExclRule*",    "default": "Vector.empty",                     "since": "0.0.1" },
        { "name": "extraAttributes",   "type": "Map[String, String]",                    "default": "Map.empty",                        "since": "0.0.1" },
        { "name": "crossVersion",      "type": "sbt.librarymanagement.CrossVersion",     "default": "sbt.librarymanagement.Disabled()", "since": "0.0.1" },
-        { "name": "branchName",        "type": "Option[String]",                         "default": "None",                             "since": "0.0.1" }
+        { "name": "branchName",        "type": "Option[String]",                         "default": "None",                             "since": "0.0.1" },
+        { "name": "platformOpt",       "type": "Option[String]",                         "default": "None",                             "since": "2.0.0" }
      ],
      "toString": [
        "this.toStringImpl"
--- a/core/src/main/scala/sbt/librarymanagement/ModuleIDExtra.scala
+++ b/core/src/main/scala/sbt/librarymanagement/ModuleIDExtra.scala
@ -33,6 +33,7 @@ private[librarymanagement] abstract class ModuleIDExtra {
  def withExtraAttributes(extraAttributes: Map[String, String]): ModuleID
  def withCrossVersion(crossVersion: CrossVersion): ModuleID
  def withBranchName(branchName: Option[String]): ModuleID
+  def withPlatformOpt(platformOpt: Option[String]): ModuleID

  protected def toStringImpl: String =
    s"""$organization:$name:$revision""" +
@ -205,6 +206,8 @@ private[librarymanagement] abstract class ModuleIDExtra {
  def branch(branchName: String): ModuleID = withBranchName(Some(branchName))

  def branch(branchName: Option[String]): ModuleID = withBranchName(branchName)
+
+  def platform(platform: String): ModuleID = withPlatformOpt(Some(platform))
 }

 private[librarymanagement] abstract class ModuleIDFunctions {
--- a/core/src/main/scala/sbt/librarymanagement/Platform.scala
+++ b/core/src/main/scala/sbt/librarymanagement/Platform.scala
@ -0,0 +1,7 @@
+package sbt.librarymanagement
+
+object Platform:
+  val sjs1: String = "sjs1"
+  val jvm: String = "jvm"
+  val native0_4: String = "native0.4"
+end Platform
--- a/ivy/src/main/scala/sbt/internal/librarymanagement/Ivy.scala
+++ b/ivy/src/main/scala/sbt/internal/librarymanagement/Ivy.scala
@ -40,6 +40,7 @@ import scala.collection.mutable
 import scala.util.{ Success, Failure }
 import sbt.util._
 import sbt.librarymanagement.{ ModuleDescriptorConfiguration => InlineConfiguration, _ }
+import sbt.librarymanagement.Platform
 import sbt.librarymanagement.ivy._
 import sbt.librarymanagement.syntax._

@ -706,29 +707,45 @@ private[sbt] object IvySbt {
  private def substituteCross(m: ModuleSettings): ModuleSettings = {
    m.scalaModuleInfo match {
      case None     => m
-      case Some(is) => substituteCross(m, is.scalaFullVersion, is.scalaBinaryVersion)
+      case Some(is) => substituteCross(m, is.scalaFullVersion, is.scalaBinaryVersion, is.platform)
    }
  }

  private def substituteCross(
      m: ModuleSettings,
      scalaFullVersion: String,
-      scalaBinaryVersion: String
-  ): ModuleSettings = {
+      scalaBinaryVersion: String,
+      platform: Option[String],
+  ): ModuleSettings =
    m match {
      case ic: InlineConfiguration =>
-        val applyCross = CrossVersion(scalaFullVersion, scalaBinaryVersion)
+        val applyPlatform: ModuleID => ModuleID = substitutePlatform(platform)
+        val transform: ModuleID => ModuleID = (m: ModuleID) =>
+          val applyCross = CrossVersion(scalaFullVersion, scalaBinaryVersion)
+          applyCross(applyPlatform(m))
        def propagateCrossVersion(moduleID: ModuleID): ModuleID = {
          val crossExclusions: Vector[ExclusionRule] =
-            moduleID.exclusions.map(CrossVersion.substituteCross(_, ic.scalaModuleInfo))
-          applyCross(moduleID)
+            moduleID.exclusions
+              .map(CrossVersion.substituteCross(_, ic.scalaModuleInfo))
+          transform(moduleID)
            .withExclusions(crossExclusions)
        }
-        ic.withModule(applyCross(ic.module))
+        ic.withModule(transform(ic.module))
          .withDependencies(ic.dependencies.map(propagateCrossVersion))
-          .withOverrides(ic.overrides map applyCross)
+          .withOverrides(ic.overrides map transform)
      case _ => m
    }
+
+  private def substitutePlatform(platform: Option[String]): ModuleID => ModuleID = {
+    def addSuffix(m: ModuleID, platformName: String): ModuleID =
+      platformName match
+        case "" | Platform.jvm => m
+        case _                 => m.withName(s"${m.name}_$platformName")
+    (m: ModuleID) =>
+      (platform, m.platformOpt) match
+        case (Some(p), None) => addSuffix(m, p)
+        case (_, Some(p))    => addSuffix(m, p)
+        case _               => m
  }

  private def toIvyArtifact(
--- a/ivy/src/test/scala/sbt/internal/librarymanagement/BaseIvySpecification.scala
+++ b/ivy/src/test/scala/sbt/internal/librarymanagement/BaseIvySpecification.scala
@ -18,6 +18,8 @@ trait BaseIvySpecification extends AbstractEngineSpec {
  def defaultModuleId: ModuleID =
    ModuleID("com.example", "foo", "0.1.0").withConfigurations(Some("compile"))

+  def scala2_13 = "2.13.10"
+
  lazy val log = ConsoleLogger()
  def lmEngine(uo: UpdateOptions = UpdateOptions()): DependencyResolution =
    IvyDependencyResolution(mkIvyConfiguration(uo))
@ -37,7 +39,8 @@ trait BaseIvySpecification extends AbstractEngineSpec {
      deps: Vector[ModuleID],
      scalaFullVersion: Option[String],
      uo: UpdateOptions = UpdateOptions(),
-      overrideScalaVersion: Boolean = true
+      overrideScalaVersion: Boolean = true,
+      platform: Option[String] = None,
  ): IvySbt#Module = {
    val scalaModuleInfo = scalaFullVersion map { fv =>
      ScalaModuleInfo(
@ -48,6 +51,7 @@ trait BaseIvySpecification extends AbstractEngineSpec {
        filterImplicit = false,
        overrideScalaVersion = overrideScalaVersion
      )
+        .withPlatform(platform)
    }

    val moduleSetting: ModuleSettings = ModuleDescriptorConfiguration(moduleId, ModuleInfo("foo"))
--- a/ivy/src/test/scala/sbt/internal/librarymanagement/PlatformResolutionSpec.scala
+++ b/ivy/src/test/scala/sbt/internal/librarymanagement/PlatformResolutionSpec.scala
@ -0,0 +1,70 @@
+package sbt.internal.librarymanagement
+
+import sbt.util.ShowLines
+import sbt.librarymanagement.*
+import sbt.librarymanagement.syntax.*
+import sbt.librarymanagement.Platform.*
+
+object PlatformResolutionSpec extends BaseIvySpecification {
+
+  import TestShowLines.*
+
+  test("None platform resolves %% as JVM") {
+    cleanCache()
+    val m = exampleAutoModule(platform = None)
+    assert(
+      update(m).configurations.head.modules.map(_.toString).mkString
+        contains "com.github.scopt:scopt_2.13:4.1.0"
+    )
+  }
+
+  test("sjs1 platform resolves %% as sjs1") {
+    cleanCache()
+    val m = exampleAutoModule(platform = Some("sjs1"))
+    assert(
+      update(m).configurations.head.modules.map(_.toString).mkString
+        contains "com.github.scopt:scopt_sjs1_2.13"
+    )
+  }
+
+  test("None platform can specify .platform(sjs1) depenency") {
+    cleanCache()
+    val m = module(
+      exampleModuleId("0.6.0"),
+      deps = Vector(scopt.platform(sjs1)),
+      Some(scala2_13),
+      platform = None,
+    )
+    assert(
+      update(m).configurations.head.modules.map(_.toString).mkString
+        contains "com.github.scopt:scopt_sjs1_2.13"
+    )
+  }
+
+  test("sjs1 platform can specify .platform(jvm) depenency") {
+    cleanCache()
+    val m = module(
+      exampleModuleId("0.6.0"),
+      deps = Vector(scopt.platform(jvm)),
+      Some(scala2_13),
+      platform = None,
+    )
+    assert(
+      update(m).configurations.head.modules.map(_.toString).mkString
+        contains "com.github.scopt:scopt_2.13:4.1.0"
+    )
+  }
+
+  def exampleAutoModule(platform: Option[String]): ModuleDescriptor = module(
+    exampleModuleId("0.6.0"),
+    deps = Vector(scopt),
+    Some(scala2_13),
+    platform = platform,
+  )
+
+  def exampleModuleId(v: String): ModuleID = ("com.example" % "foo" % v % Compile)
+  def scopt = ("com.github.scopt" %% "scopt" % "4.1.0" % Compile)
+  override val resolvers = Vector(
+    Resolver.mavenCentral,
+  )
+}