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 `%%`).

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 = {
+  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)
+    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)
 }

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()
   }
 }

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 = {
+  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)
+    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)
 }

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()
   }
 }

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"

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 {

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

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
+      scalaBinaryVersion: String,
-  ): ModuleSettings = {
+      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))
+            moduleID.exclusions
-          applyCross(moduleID)
+              .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(

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"))

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,
+  )
+}