Fix #8571: A new source version and migration scheme

Unlike originally proposed in #8571, we now just use -source, the separate
-migration setting is gone. We replace it by having source versions for migrations.
So, right now, we have

 3.0, 3.1, 3.0-migration and 3.1-migration.

A X-migration source level means that migration warnings and changes in preparation
for the X source level are enabled.

So, the scenarios in #8571 would map as follows:

 - I want to cross compile between Scala 2 and Scala 3: not yet implemented, but it would be -source 2x3
 - I want help with migration to Scala 3: -source 3.0-migration
 - I want help with migration to the cross-compilable subset: not yet implemented, but it would be -source 2x3-migration
 - I want to make sure my code is future-proof for 3.1: -source 3.1
 - I want help making my code future-proof for 3.1: -source 3.1-migration
 - My compiler's version is3.1, but I want to stick to the more lenient 3.0 version for the moment: -source 3.0.
 - My compiler's version is 3.1, but I want to stick to the cross-compilable subset: not yet implemented, but it would be -source 2x3

Author: odersky

compiler/src/dotty/tools/dotc/Driver.scala

@@ -5,12 +5,14 @@ import java.nio.file.{Files, Paths}
 import dotty.tools.FatalError
 import config.CompilerCommand
 import core.Comments.{ContextDoc, ContextDocstrings}
-import core.Contexts.{Context, ContextBase}
+import core.Contexts.{Context, ContextBase, inContext, ctx}
 import core.{MacroClassLoader, Mode, TypeError}
+import core.StdNames.nme
 import dotty.tools.dotc.ast.Positioned
 import dotty.tools.io.File
 import reporting._
 import core.Decorators._
+import config.Feature
 
 import scala.util.control.NonFatal
 import fromtasty.{TASTYCompiler, TastyFileUtil}
@@ -70,11 +72,14 @@ class Driver {
     MacroClassLoader.init(ictx)
     Positioned.updateDebugPos(ictx)
 
-    if (!ictx.settings.YdropComments.value(ictx) || ictx.mode.is(Mode.ReadComments))
-      ictx.setProperty(ContextDoc, new ContextDocstrings)
-
-    val fileNames = CompilerCommand.checkUsage(summary, sourcesRequired)(ictx)
-    fromTastySetup(fileNames, ictx)
+    inContext(ictx) {
+      if !ctx.settings.YdropComments.value || ctx.mode.is(Mode.ReadComments) then
+        ictx.setProperty(ContextDoc, new ContextDocstrings)
+      if Feature.enabledBySetting(nme.Scala2Compat) then
+        ctx.warning("-language:Scala2Compat will go away; use -source 3.0-migration instead")
+      val fileNames = CompilerCommand.checkUsage(summary, sourcesRequired)
+      fromTastySetup(fileNames, ctx)
+    }
   }
 
   /** Setup extra classpath and figure out class names for tasty file inputs */

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -9,6 +9,7 @@ import Decorators.{given _}, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import typer.{FrontEnd, Namer}
 import util.{Property, SourceFile, SourcePosition}
+import config.Feature
 import collection.mutable.ListBuffer
 import reporting.messages._
 import reporting.trace
@@ -560,7 +561,7 @@ object desugar {
       ensureApplied(nu)
     }
 
-    val copiedAccessFlags = if (ctx.scala2CompatSetting) EmptyFlags else AccessFlags
+    val copiedAccessFlags = if Feature.migrateTo3 then EmptyFlags else AccessFlags
 
     // Methods to add to a case class C[..](p1: T1, ..., pN: Tn)(moreParams)
     //     def _1: T1 = this.p1
@@ -1659,7 +1660,7 @@ object desugar {
         }
         else {
           assert(ctx.mode.isExpr || ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), ctx.mode)
-          if (!ctx.featureEnabled(nme.postfixOps)) {
+          if (!Feature.enabled(nme.postfixOps)) {
             ctx.error(
               s"""postfix operator `${op.name}` needs to be enabled
                  |by making the implicit value scala.language.postfixOps visible.

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -0,0 +1,81 @@
+package dotty.tools
+package dotc
+package config
+
+import core._
+import Contexts._, Symbols._, Names._
+import StdNames.nme
+import Decorators.{given _}
+import util.SourcePosition
+import SourceVersion._
+import reporting.Message
+
+object Feature:
+
+/** Is `feature` enabled by by a command-line setting? The enabling setting is
+   *
+   *       -language:<prefix>feature
+   *
+   *  where <prefix> is the fully qualified name of `owner`, followed by a ".",
+   *  but subtracting the prefix `scala.language.` at the front.
+   */
+  def enabledBySetting(feature: TermName, owner: Symbol = NoSymbol)(using Context): Boolean =
+    def toPrefix(sym: Symbol): String =
+      if !sym.exists || sym == defn.LanguageModule.moduleClass then ""
+      else toPrefix(sym.owner) + sym.name + "."
+    val prefix = if owner.exists then toPrefix(owner) else ""
+    ctx.base.settings.language.value.contains(prefix + feature)
+
+  /** Is `feature` enabled by by an import? This is the case if the feature
+   *  is imported by a named import
+   *
+   *       import owner.feature
+   *
+   *  and there is no visible nested import that excludes the feature, as in
+   *
+   *       import owner.{ feature => _ }
+   */
+  def enabledByImport(feature: TermName, owner: Symbol = NoSymbol)(using Context): Boolean =
+    ctx.atPhase(ctx.typerPhase) {
+      ctx.importInfo != null
+      && ctx.importInfo.featureImported(feature.toTermName,
+          if owner.exists then owner else defn.LanguageModule.moduleClass)
+    }
+
+  /** Is `feature` enabled by either a command line setting or an import?
+   *  @param  feature   The name of the feature
+   *  @param  owner     The prefix symbol (nested in `scala.language`) where the
+   *                    feature is defined.
+   */
+  def enabled(feature: TermName, owner: Symbol = NoSymbol)(using Context): Boolean =
+    enabledBySetting(feature, owner) || enabledByImport(feature, owner)
+
+  /** Is auto-tupling enabled? */
+  def autoTuplingEnabled(using Context): Boolean =
+    !enabled(nme.noAutoTupling)
+
+  def dynamicsEnabled(using Context): Boolean =
+    enabled(nme.dynamics)
+
+  def sourceVersionSetting(using Context): SourceVersion =
+    SourceVersion.valueOf(ctx.settings.source.value)
+
+  def sourceVersion(using Context): SourceVersion =
+    if ctx.importInfo == null then sourceVersionSetting
+    else ctx.importInfo.sourceVersion.getOrElse(sourceVersionSetting)
+
+  def migrateTo3(using Context): Boolean =
+    sourceVersion == `3.0-migration` || enabledBySetting(nme.Scala2Compat)
+
+  /** If current source migrates to `version`, issue given warning message
+   *  and return `true`, otherwise return `false`.
+   */
+  def warnOnMigration(msg: Message, pos: SourcePosition,
+      version: SourceVersion = defaultSourceVersion)(using Context): Boolean =
+    if sourceVersion.isMigrating && sourceVersion.stable == version then
+      ctx.migrationWarning(msg, pos)
+      true
+    else
+      false
+
+end Feature

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -34,6 +34,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val feature: Setting[Boolean] = BooleanSetting("-feature", "Emit warning and location for usages of features that should be imported explicitly.") withAbbreviation "--feature"
   val help: Setting[Boolean] = BooleanSetting("-help", "Print a synopsis of standard options.") withAbbreviation "--help"
   val color: Setting[String] = ChoiceSetting("-color", "mode", "Colored output", List("always", "never"/*, "auto"*/), "always"/* "auto"*/) withAbbreviation "--color"
+  val source: Setting[String] = ChoiceSetting("-source", "source version", "source version", List("3.0", "3.1", "3.0-migration", "3.1-migration"), "3.0").withAbbreviation("--source")
   val target: Setting[String] = ChoiceSetting("-target", "target", "Target platform for object files. All JVM 1.5 targets are deprecated.",
     List("jvm-1.5", "jvm-1.5-fjbg", "jvm-1.5-asm", "jvm-1.6", "jvm-1.7", "jvm-1.8", "msil"), "jvm-1.8") withAbbreviation "--target"
   val scalajs: Setting[Boolean] = BooleanSetting("-scalajs", "Compile in Scala.js mode (requires scalajs-library.jar on the classpath).") withAbbreviation "--scalajs"
@@ -45,7 +46,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val pageWidth: Setting[Int] = IntSetting("-pagewidth", "Set page width", 80) withAbbreviation "--page-width"
   val strict: Setting[Boolean] = BooleanSetting("-strict", "Use strict type rules, which means some formerly legal code does not typecheck anymore.") withAbbreviation "--strict"
   val language: Setting[List[String]] = MultiStringSetting("-language", "feature", "Enable one or more language features.") withAbbreviation "--language"
-  val rewrite: Setting[Option[Rewrites]] = OptionSetting[Rewrites]("-rewrite", "When used in conjunction with -language:Scala2Compat rewrites sources to migrate to new syntax.") withAbbreviation "--rewrite"
+  val rewrite: Setting[Option[Rewrites]] = OptionSetting[Rewrites]("-rewrite", "When used in conjunction with a `...-migration` source version, rewrites sources to migrate to new version.") withAbbreviation "--rewrite"
   val silentWarnings: Setting[Boolean] = BooleanSetting("-nowarn", "Silence all warnings.") withAbbreviation "--no-warnings"
   val fromTasty: Setting[Boolean] = BooleanSetting("-from-tasty", "Compile classes from tasty in classpath. The arguments are used as class names.") withAbbreviation "--from-tasty"
 

compiler/src/dotty/tools/dotc/config/SourceVersion.scala

@@ -0,0 +1,25 @@
+package dotty.tools
+package dotc
+package config
+
+import core.Contexts.{Context, ctx}
+import core.Names.TermName
+import core.StdNames.nme
+import core.Decorators.{given _}
+import util.Property
+
+enum SourceVersion:
+  case `3.0-migration`, `3.0`, `3.1-migration`, `3.1`
+
+  val isMigrating: Boolean = toString.endsWith("-migration")
+
+  def stable: SourceVersion =
+    if isMigrating then SourceVersion.values(ordinal + 1) else this
+
+  def isAtLeast(v: SourceVersion) = stable.ordinal >= v.ordinal
+
+object SourceVersion extends Property.Key[SourceVersion]:
+  def defaultSourceVersion = `3.0`
+
+  val allSourceVersionNames = values.toList.map(_.toString.toTermName)
+end SourceVersion

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -17,6 +17,7 @@ import Decorators._
 import printing.Texts._
 import printing.Printer
 import io.AbstractFile
+import config.Feature.migrateTo3
 import config.Config
 import util.common._
 import typer.ProtoTypes.NoViewsAllowed
@@ -489,7 +490,7 @@ object Denotations {
                   // things, starting with the return type of this method.
                   if (preferSym(sym2, sym1)) info2
                   else if (preferSym(sym1, sym2)) info1
-                  else if (pre.widen.classSymbol.is(Scala2x) || ctx.scala2CompatMode)
+                  else if (pre.widen.classSymbol.is(Scala2x) || migrateTo3)
                     info1 // follow Scala2 linearization -
                   // compare with way merge is performed in SymDenotation#computeMembersNamed
                   else throw new MergeError(ex.sym1, ex.sym2, ex.tp1, ex.tp2, pre)

compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala

@@ -7,6 +7,7 @@ import Symbols._
 import Types._
 import Flags._
 import dotty.tools.dotc.reporting.trace
+import config.Feature.migrateTo3
 import config.Printers._
 
 trait PatternTypeConstrainer { self: TypeComparer =>
@@ -199,7 +200,9 @@ trait PatternTypeConstrainer { self: TypeComparer =>
       }
     }
 
-    val widePt = if (ctx.scala2CompatMode || refinementIsInvariant(patternTp)) scrutineeTp else widenVariantParams(scrutineeTp)
+    val widePt =
+      if migrateTo3 || refinementIsInvariant(patternTp) then scrutineeTp
+      else widenVariantParams(scrutineeTp)
     val narrowTp = SkolemType(patternTp)
     trace(i"constraining simple pattern type $narrowTp <:< $widePt", gadts, res => s"$res\ngadt = ${ctx.gadt.debugBoundsDescription}") {
       isSubType(narrowTp, widePt)

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -502,6 +502,7 @@ object StdNames {
     val java: N                 = "java"
     val key: N                  = "key"
     val lang: N                 = "lang"
+    val language: N             = "language"
     val length: N               = "length"
     val lengthCompare: N        = "lengthCompare"
     val macroThis : N           = "_this"

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -8,6 +8,7 @@ import StdNames.nme
 import collection.mutable
 import util.Stats
 import config.Config
+import config.Feature.migrateTo3
 import config.Printers.{constr, subtyping, gadts, noPrinter}
 import TypeErasure.{erasedLub, erasedGlb}
 import TypeApplications._
@@ -584,7 +585,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
             * am not sure how, since the code is buried so deep in subtyping logic.
             */
             def boundsOK =
-              ctx.scala2CompatMode ||
+              migrateTo3 ||
               tp1.typeParams.corresponds(tp2.typeParams)((tparam1, tparam2) =>
                 isSubType(tparam2.paramInfo.subst(tp2, tp1), tparam1.paramInfo))
             val saved = comparedTypeLambdas
@@ -1826,7 +1827,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
   /** The greatest lower bound of a list types */
   final def glb(tps: List[Type]): Type = tps.foldLeft(AnyType: Type)(glb)
 
-  def widenInUnions(implicit ctx: Context): Boolean = ctx.scala2CompatMode || ctx.erasedTypes
+  def widenInUnions(implicit ctx: Context): Boolean =
+    migrateTo3 || ctx.erasedTypes
 
   /** The least upper bound of two types
    *  @param canConstrain  If true, new constraints might be added to simplify the lub.

compiler/src/dotty/tools/dotc/core/TypeOps.scala

@@ -14,6 +14,7 @@ import collection.mutable
 import ast.tpd._
 import reporting.{trace, Message}
 import config.Printers.{gadts, typr}
+import config.Feature
 import typer.Applications._
 import typer.ProtoTypes._
 import typer.ForceDegree
@@ -378,7 +379,8 @@ trait TypeOps { thisCtx: Context => // TODO: Make standalone object.
      *  type parameter corresponding to the wildcard.
      */
     def skolemizeWildcardArgs(tps: List[Type], app: Type) = app match {
-      case AppliedType(tycon: TypeRef, args) if tycon.typeSymbol.isClass && !scala2CompatMode =>
+      case AppliedType(tycon: TypeRef, args)
+      if tycon.typeSymbol.isClass && !Feature.migrateTo3 =>
         tps.zipWithConserve(tycon.typeSymbol.typeParams) {
           (tp, tparam) => tp match {
             case _: TypeBounds => app.select(tparam)
@@ -469,66 +471,6 @@ trait TypeOps { thisCtx: Context => // TODO: Make standalone object.
   /** Are we in a macro? */
   def inMacro: Boolean = owner.ownersIterator.exists(s => s.isInlineMethod && s.is(Macro))
 
-  /** Is `feature` enabled in class `owner`?
-   *  This is the case if one of the following two alternatives holds:
-   *
-   *  1. The feature is imported by a named import
-   *
-   *       import owner.feature
-   *
-   *     and there is no visible nested import that excludes the feature, as in
-   *
-   *       import owner.{ feature => _ }
-   *
-   *  The feature may be bunched with others, or renamed, but wildcard imports don't count.
-   *
-   *  2. The feature is enabled by a compiler option
-   *
-   *       - language:<prefix>feature
-   *
-   *  where <prefix> is the full name of the owner followed by a "." minus
-   *  the prefix "dotty.language.".
-   */
-  def featureEnabled(feature: TermName, owner: Symbol = NoSymbol): Boolean = {
-    def hasImport = {
-      val owner1 = if (!owner.exists) defn.LanguageModule.moduleClass else owner
-      thisCtx.importInfo != null &&
-      thisCtx.importInfo.featureImported(feature, owner1)(using thisCtx.withPhase(thisCtx.typerPhase))
-    }
-    val hasOption = {
-      def toPrefix(sym: Symbol): String =
-        if (!sym.exists) ""
-        else toPrefix(sym.owner) + sym.name + "."
-      val featureName = toPrefix(owner) + feature
-      thisCtx.base.settings.language.value contains featureName
-    }
-    hasOption || hasImport
-  }
-
-  /** Is auto-tupling enabled? */
-  def canAutoTuple: Boolean =
-    !featureEnabled(nme.noAutoTupling)
-
-  def scala2CompatMode: Boolean =
-    featureEnabled(nme.Scala2Compat)
-
-  def dynamicsEnabled: Boolean =
-    featureEnabled(nme.dynamics)
-
-  def testScala2CompatMode(msg: Message, pos: SourcePosition, replace: => Unit = ()): Boolean = {
-    if (scala2CompatMode) {
-      migrationWarning(msg, pos)
-      replace
-    }
-    scala2CompatMode
-  }
-
-  /** Is option -language:Scala2Compat set?
-   *  This test is used when we are too early in the pipeline to consider imports.
-   */
-  def scala2CompatSetting: Boolean =
-    thisCtx.settings.language.value.contains(nme.Scala2Compat.toString)
-
   /** Refine child based on parent
    *
    *  In child class definition, we have: