Respect user target always

src/compiler/scala/tools/nsc/backend/jvm/PostProcessorFrontendAccess.scala

@@ -16,11 +16,11 @@ package backend.jvm
 import scala.collection.mutable.Clearable
 import scala.reflect.internal.util.{JavaClearable, Position, Statistics}
 import scala.reflect.io.AbstractFile
+import scala.tools.nsc.Reporting.WarningCategory
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
+import scala.util.chaining._
 import java.util.{Collection => JCollection, Map => JMap}
 
-import scala.tools.nsc.Reporting.WarningCategory
-
 /**
  * Functionality needed in the post-processor whose implementation depends on the compiler
  * frontend. All methods are synchronized.
@@ -186,7 +186,13 @@ object PostProcessorFrontendAccess {
 
       @inline def debug: Boolean = s.isDebug
 
-      val target: String = s.targetValue
+      val target: String = s.targetValue.tap { value =>
+        s.releaseValue.foreach { release =>
+          if (value.toInt < release.toInt)
+            directBackendReporting.warning(NoPosition,
+              s"target platform version $value is older than the release version $release")
+        }
+      }
 
       private val singleOutDir = s.outputDirs.getSingleOutput
       // the call to `outputDirFor` should be frontendSynch'd, but we assume that the setting is not mutated during the backend

src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala

@@ -73,7 +73,7 @@ trait StandardScalaSettings { _: MutableSettings =>
       // .withAbbreviation("-Xtarget")
       // .withAbbreviation("-Xunchecked-java-output-version")
       .withDeprecationMessage("Use -release instead to compile against the correct platform API.")
-  def targetValue: String = releaseValue.getOrElse(target.value)
+  def targetValue: String = target.valueSetByUser.orElse(releaseValue).getOrElse(target.value)
   val unchecked =      BooleanSetting ("-unchecked", "Enable additional warnings where generated code depends on assumptions. See also -Wconf.") withAbbreviation "--unchecked" withPostSetHook { s =>
     if (s.value) Wconf.tryToSet(List(s"cat=unchecked:w"))
     else Wconf.tryToSet(List(s"cat=unchecked:s"))

test/junit/scala/tools/nsc/settings/TargetTest.scala

@@ -19,12 +19,17 @@ import org.junit.runners.JUnit4
 
 import scala.collection.mutable.ListBuffer
 import scala.tools.nsc.settings.StandardScalaSettings._
+import scala.tools.testkit.AssertUtil.assertFails
 import scala.util.Properties.isJavaAtLeast
 import scala.util.Try
 
 @RunWith(classOf[JUnit4])
 class TargetTest {
 
+  private def lately[A](body: => A): Unit = if (isJavaAtLeast(11)) body: Unit
+
+  private def eightly[A](body: => A): Unit = if (!isJavaAtLeast(9)) body: Unit
+
   @Test def testSettingTargetSetting(): Unit = {
     def goodVersion(v: String): Boolean = Try(isJavaAtLeast(v)).getOrElse(false)
     def check(in: String, expect: String) = if (goodVersion(expect)) checkSuccess(in, expect) else checkFail(in)
@@ -65,4 +70,35 @@ class TargetTest {
     checkFail("-target:jvm-3000") // not in our lifetime
     checkFail("-target:msil")     // really?
   }
+  @Test def `respect user target`: Unit = lately {
+    val settings = new Settings(err => fail(s"Error output: $err"))
+    val (ok, _) = settings.processArgumentString("--release:11 --target:8")
+    assertTrue(ok)
+    assertEquals("8", settings.target.value)
+    assertEquals("11", settings.release.value)
+    assertEquals("8", settings.targetValue)
+    assertEquals(Some("11"), settings.releaseValue)
+  }
+  @Test def `target is release if specified`: Unit = lately {
+    val settings = new Settings(err => fail(s"Error output: $err"))
+    val (ok, _) = settings.processArgumentString("--release:11")
+    assertTrue(ok)
+    assertEquals("8", settings.target.value)        // default
+    assertEquals(None, settings.target.valueSetByUser)
+    assertEquals("11", settings.release.value)
+    assertEquals("11", settings.targetValue)        // because --release:11
+    assertEquals(Some("11"), settings.releaseValue)
+  }
+  @Test def `disrespect user target`: Unit = lately {
+    val settings = new Settings(err => fail(s"Error output: $err"))
+    assertFails(_.contains("-release cannot be less than -target")) {
+      settings.processArgumentString("--release:8 --target:11")
+    }
+  }
+  @Test def `cannot bump release on jdk 8`: Unit = eightly {
+    val settings = new Settings(err => fail(s"Error output: $err"))
+    assertFails(_.contains("'9' is not a valid choice for '-release'")) {
+      settings.processArgumentString("--release:9")
+    }
+  }
 }