Replace -strict with -source 3.1

Author: odersky

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

@@ -9,7 +9,8 @@ import Decorators.{given _}, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import typer.{FrontEnd, Namer}
 import util.{Property, SourceFile, SourcePosition}
-import config.Feature
+import config.Feature.{sourceVersion, migrateTo3, enabled}
+import config.SourceVersion._
 import collection.mutable.ListBuffer
 import reporting.messages._
 import reporting.trace
@@ -211,7 +212,7 @@ object desugar {
     val epbuf = ListBuffer[ValDef]()
     def desugarContextBounds(rhs: Tree): Tree = rhs match {
       case ContextBounds(tbounds, cxbounds) =>
-        val iflag = if ctx.settings.strict.value then Given else Implicit
+        val iflag = if sourceVersion.isAtLeast(`3.1`) then Given else Implicit
         epbuf ++= makeImplicitParameters(cxbounds, iflag, forPrimaryConstructor = isPrimaryConstructor)
         tbounds
       case LambdaTypeTree(tparams, body) =>
@@ -561,7 +562,7 @@ object desugar {
       ensureApplied(nu)
     }
 
-    val copiedAccessFlags = if Feature.migrateTo3 then EmptyFlags else AccessFlags
+    val copiedAccessFlags = if migrateTo3 then EmptyFlags else AccessFlags
 
     // Methods to add to a case class C[..](p1: T1, ..., pN: Tn)(moreParams)
     //     def _1: T1 = this.p1
@@ -1660,7 +1661,7 @@ object desugar {
         }
         else {
           assert(ctx.mode.isExpr || ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), ctx.mode)
-          if (!Feature.enabled(nme.postfixOps)) {
+          if (!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/ast/untpd.scala

@@ -154,7 +154,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   enum GenCheckMode {
     case Ignore       // neither filter nor check since filtering was done before
     case Check        // check that pattern is irrefutable
-    case FilterNow    //filter out non-matching elements since we are not in -strict
+    case FilterNow    //filter out non-matching elements since we are not yet in 3.1
     case FilterAlways // filter out non-matching elements since pattern is prefixed by `case`
   }
 

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

@@ -44,7 +44,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val verbose: Setting[Boolean] = BooleanSetting("-verbose", "Output messages about what the compiler is doing.") withAbbreviation "--verbose"
   val version: Setting[Boolean] = BooleanSetting("-version", "Print product version and exit.") withAbbreviation "--version"
   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 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"

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

@@ -6,6 +6,8 @@ import Contexts._, Types._, Symbols._, Names._, Flags._
 import Denotations.SingleDenotation
 import Decorators._
 import collection.mutable
+import config.SourceVersion.`3.1`
+import config.Feature.sourceVersion
 
 /** Realizability status */
 object CheckRealizable {
@@ -197,7 +199,7 @@ class CheckRealizable(implicit ctx: Context) {
           realizability(fld.info).mapError(r => new HasProblemField(fld, r))
         }
       }
-    if (ctx.settings.strict.value)
+    if sourceVersion.isAtLeast(`3.1`) then
       // check fields only under strict mode for now.
       // Reason: An embedded field could well be nullable, which means it
       // should not be part of a path and need not be checked; but we cannot recognize

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -28,6 +28,8 @@ import scala.annotation.{tailrec, switch}
 import rewrites.Rewrites.{patch, overlapsPatch}
 import reporting.Message
 import reporting.messages._
+import config.Feature.sourceVersion
+import config.SourceVersion.`3.1`
 
 object Parsers {
 
@@ -1484,7 +1486,7 @@ object Parsers {
         if in.token == LBRACE || in.token == INDENT then
           t
         else
-          if (ctx.settings.strict.value)
+          if sourceVersion.isAtLeast(`3.1`) then
             deprecationWarning(DeprecatedWithOperator(), withOffset)
           makeAndType(t, withType())
       else t
@@ -1545,10 +1547,9 @@ object Parsers {
         SingletonTypeTree(literal(negOffset = start, inType = true))
       }
       else if (in.token == USCORE) {
-        if (ctx.settings.strict.value) {
+        if sourceVersion.isAtLeast(`3.1`) then
           deprecationWarning(em"`_` is deprecated for wildcard arguments of types: use `?` instead")
           patch(source, Span(in.offset, in.offset + 1), "?")
-        }
         val start = in.skipToken()
         typeBounds().withSpan(Span(start, in.lastOffset, start))
       }
@@ -2076,7 +2077,7 @@ object Parsers {
         val name = bindingName()
         val t =
           if (in.token == COLON && location == Location.InBlock) {
-            if (ctx.settings.strict.value)
+            if sourceVersion.isAtLeast(`3.1`)
                 // Don't error in non-strict mode, as the alternative syntax "implicit (x: T) => ... "
                 // is not supported by Scala2.x
               in.errorOrMigrationWarning(s"This syntax is no longer supported; parameter needs to be enclosed in (...)")
@@ -2396,7 +2397,7 @@ object Parsers {
       atSpan(startOffset(pat), accept(LARROW)) {
         val checkMode =
           if (casePat) GenCheckMode.FilterAlways
-          else if (ctx.settings.strict.value) GenCheckMode.Check
+          else if sourceVersion.isAtLeast(`3.1`) then GenCheckMode.Check
           else GenCheckMode.FilterNow  // filter for now, to keep backwards compat
         GenFrom(pat, subExpr(), checkMode)
       }
@@ -2574,15 +2575,15 @@ object Parsers {
         // compatibility for Scala2 `x @ _*` syntax
         infixPattern() match {
           case pt @ Ident(tpnme.WILDCARD_STAR) =>
-            if (ctx.settings.strict.value)
+            if sourceVersion.isAtLeast(`3.1`) then
               in.errorOrMigrationWarning("The syntax `x @ _*` is no longer supported; use `x : _*` instead", Span(startOffset(p)))
             atSpan(startOffset(p), offset) { Typed(p, pt) }
           case pt =>
             atSpan(startOffset(p), 0) { Bind(name, pt) }
         }
       case p @ Ident(tpnme.WILDCARD_STAR) =>
         // compatibility for Scala2 `_*` syntax
-        if (ctx.settings.strict.value)
+        if sourceVersion.isAtLeast(`3.1`) then
           in.errorOrMigrationWarning("The syntax `_*` is no longer supported; use `x : _*` instead", Span(startOffset(p)))
         atSpan(startOffset(p)) { Typed(Ident(nme.WILDCARD), p) }
       case p =>
@@ -2717,7 +2718,7 @@ object Parsers {
           syntaxError(DuplicatePrivateProtectedQualifier())
         inBrackets {
           if in.token == THIS then
-            if ctx.settings.strict.value then
+            if sourceVersion.isAtLeast(`3.1`) then
               deprecationWarning("The [this] qualifier is deprecated in Scala 3.1; it should be dropped.")
             in.nextToken()
             mods | Local

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -124,10 +124,6 @@ trait Reporting { thisCtx: Context =>
   def warning(msg: Message, pos: SourcePosition = NoSourcePosition): Unit =
     reportWarning(new Warning(msg, addInlineds(pos)))
 
-  def strictWarning(msg: Message, pos: SourcePosition = NoSourcePosition): Unit =
-    if (thisCtx.settings.strict.value) error(msg, pos)
-    else warning(msg.append("\n(This would be an error under strict mode)"), pos)
-
   def error(msg: Message, pos: SourcePosition = NoSourcePosition, sticky: Boolean = false): Unit = {
     val fullPos = addInlineds(pos)
     reporter.report(if (sticky) new StickyError(msg, fullPos) else new Error(msg, fullPos))

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -32,7 +32,8 @@ import NameOps._
 import SymDenotations.{NoCompleter, NoDenotation}
 import Applications.unapplyArgs
 import transform.patmat.SpaceEngine.isIrrefutableUnapply
-import config.Feature
+import config.Feature._
+import config.SourceVersion._
 
 import collection.mutable
 import reporting.Message
@@ -309,7 +310,8 @@ object Checking {
     }
   }
 
-  /** If `sym` has an operator name, check that it has an @alpha annotation under -strict */
+  /** If `sym` has an operator name, check that it has an @alpha annotation in 3.1 and later
+   */
   def checkValidOperator(sym: Symbol)(using Context): Unit =
     sym.name.toTermName match {
       case name: SimpleName
@@ -318,7 +320,7 @@ object Checking {
          && !name.isConstructorName
          && !sym.getAnnotation(defn.AlphaAnnot).isDefined
          && !sym.is(Synthetic)
-         && ctx.settings.strict.value =>
+         && sourceVersion.isAtLeast(`3.1`) =>
         ctx.deprecationWarning(
           i"$sym has an operator name; it should come with an @alpha annotation", sym.sourcePos)
       case _ =>
@@ -683,7 +685,7 @@ trait Checking {
     def check(pat: Tree, pt: Type): Boolean = (pt <:< pat.tpe) || fail(pat, pt)
 
     def recur(pat: Tree, pt: Type): Boolean =
-      !ctx.settings.strict.value || // only in -strict mode for now since mitigations work only after this PR
+      !sourceVersion.isAtLeast(`3.1`) || // only for 3.1 for now since mitigations work only after this PR
       pat.tpe.widen.hasAnnotation(defn.UncheckedAnnot) || {
         patmatch.println(i"check irrefutable $pat: ${pat.tpe} against $pt")
         pat match {
@@ -804,7 +806,7 @@ trait Checking {
              !isInfix(meth) &&
              !meth.maybeOwner.is(Scala2x) &&
              !infixOKSinceFollowedBy(tree.right) &&
-             ctx.settings.strict.value =>
+             sourceVersion.isAtLeast(`3.1`) =>
             val (kind, alternative) =
               if (ctx.mode.is(Mode.Type))
                 ("type", (n: Name) => s"prefix syntax $n[...]")
@@ -831,7 +833,7 @@ trait Checking {
                    description: => String,
                    featureUseSite: Symbol,
                    pos: SourcePosition)(using Context): Unit =
-    if !Feature.enabled(name) then
+    if !enabled(name) then
       ctx.featureWarning(name.toString, description, featureUseSite, required = false, pos)
 
   /** Check that `tp` is a class type and that any top-level type arguments in this type

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -23,6 +23,8 @@ import transform.ValueClasses._
 import transform.TypeUtils._
 import transform.SymUtils._
 import reporting.messages._
+import config.Feature.sourceVersion
+import config.SourceVersion._
 
 trait NamerContextOps {
   thisCtx: Context =>
@@ -1261,7 +1263,7 @@ class Namer { typer: Typer =>
             else if pclazz.isEffectivelySealed && pclazz.associatedFile != cls.associatedFile then
               if pclazz.is(Sealed) then
                 completerCtx.error(UnableToExtendSealedClass(pclazz), cls.sourcePos)
-              else if completerCtx.settings.strict.value then
+              else if sourceVersion.isAtLeast(`3.1`) then
                 checkFeature(nme.adhocExtensions,
                   i"Unless $pclazz is declared 'open', its extension in a separate file",
                   cls.topLevelClass,

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -34,7 +34,7 @@ import annotation.tailrec
 import Implicits._
 import util.Stats.record
 import config.Printers.{gadts, typr}
-import config.Feature
+import config.Feature._
 import config.SourceVersion._
 import rewrites.Rewrites.patch
 import NavigateAST._
@@ -319,7 +319,7 @@ class Typer extends Namer
                   ctx.errorOrMigrationWarning(
                     AmbiguousReference(name, Definition, Inheritance, prevCtx)(using outer),
                     posd.sourcePos)
-                  if Feature.migrateTo3 then
+                  if migrateTo3 then
                     patch(Span(posd.span.start),
                       if prevCtx.owner == refctx.owner.enclosingClass then "this."
                       else s"${prevCtx.owner.name}.this.")
@@ -348,7 +348,7 @@ class Typer extends Namer
                     checkNoOuterDefs(found.denot, ctx, ctx)
                   case _ =>
               else
-                if Feature.migrateTo3 && !foundUnderScala2.exists then
+                if migrateTo3 && !foundUnderScala2.exists then
                   foundUnderScala2 = checkNewOrShadowed(found, Definition, scala2pkg = true)
                 if (defDenot.symbol.is(Package))
                   result = checkNewOrShadowed(previous orElse found, PackageClause)
@@ -1934,7 +1934,7 @@ class Typer extends Namer
         ctx.phase.isTyper &&
         cdef1.symbol.ne(defn.DynamicClass) &&
         cdef1.tpe.derivesFrom(defn.DynamicClass) &&
-        !Feature.dynamicsEnabled
+        !dynamicsEnabled
       if (reportDynamicInheritance) {
         val isRequired = parents1.exists(_.tpe.isRef(defn.DynamicClass))
         ctx.featureWarning(nme.dynamics.toString, "extension of type scala.Dynamic", cls, isRequired, cdef.sourcePos)
@@ -2103,15 +2103,15 @@ class Typer extends Namer
       case _ =>
         val recovered = typed(qual)(using ctx.fresh.setExploreTyperState())
         ctx.errorOrMigrationWarning(OnlyFunctionsCanBeFollowedByUnderscore(recovered.tpe.widen), tree.sourcePos)
-        if (Feature.migrateTo3) {
+        if (migrateTo3) {
           // Under -rewrite, patch `x _` to `(() => x)`
           patch(Span(tree.span.start), "(() => ")
           patch(Span(qual.span.end, tree.span.end), ")")
           return typed(untpd.Function(Nil, qual), pt)
         }
     }
     nestedCtx.typerState.commit()
-    if (ctx.settings.strict.value) {
+    if sourceVersion.isAtLeast(`3.1`) then
       lazy val (prefix, suffix) = res match {
         case Block(mdef @ DefDef(_, _, vparams :: Nil, _, _) :: Nil, _: Closure) =>
           val arity = vparams.length
@@ -2123,12 +2123,11 @@ class Typer extends Namer
         if ((prefix ++ suffix).isEmpty) "simply leave out the trailing ` _`"
         else s"use `$prefix<function>$suffix` instead"
       ctx.errorOrMigrationWarning(i"""The syntax `<function> _` is no longer supported;
-                                     |you can $remedy""", tree.sourcePos)
-      if (Feature.migrateTo3) {
+                                     |you can $remedy""", tree.sourcePos, `3.1`)
+      if sourceVersion.isMigrating then
         patch(Span(tree.span.start), prefix)
         patch(Span(qual.span.end, tree.span.end), suffix)
-      }
-    }
+    end if
     res
   }
 
@@ -2756,17 +2755,16 @@ class Typer extends Namer
       case wtp: MethodOrPoly =>
         def methodStr = methPart(tree).symbol.showLocated
         if (matchingApply(wtp, pt))
-          if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && Feature.autoTuplingEnabled)
+          if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && autoTuplingEnabled)
             adapt(tree, pt.tupled, locked)
           else
             tree
         else if (wtp.isContextualMethod)
           def isContextBoundParams = wtp.stripPoly match
             case MethodType(EvidenceParamName(_) :: _) => true
             case _ => false
-          if ctx.settings.migration.value && ctx.settings.strict.value
-             && isContextBoundParams
-          then // Under 3.1 and -migration, don't infer implicit arguments yet for parameters
+          if sourceVersion == `3.1-migration` && isContextBoundParams
+          then // Under 3.1-migration, don't infer implicit arguments yet for parameters
                // coming from context bounds. Issue a warning instead and offer a patch.
             ctx.migrationWarning(
               em"""Context bounds will map to context parameters.
@@ -2928,7 +2926,7 @@ class Typer extends Namer
       def isAutoApplied(sym: Symbol): Boolean =
         sym.isConstructor
         || sym.matchNullaryLoosely
-        || Feature.warnOnMigration(MissingEmptyArgumentList(sym), tree.sourcePos)
+        || warnOnMigration(MissingEmptyArgumentList(sym), tree.sourcePos)
            && { patch(tree.span.endPos, "()"); true }
 
       // Reasons NOT to eta expand:
@@ -3266,7 +3264,7 @@ class Typer extends Namer
         case ref: TermRef =>
           pt match {
             case pt: FunProto
-            if pt.args.lengthCompare(1) > 0 && isUnary(ref) && Feature.autoTuplingEnabled =>
+            if pt.args.lengthCompare(1) > 0 && isUnary(ref) && autoTuplingEnabled =>
               adapt(tree, pt.tupled, locked)
             case _ =>
               adaptOverloaded(ref)