Set source version to future under magic

Author: odersky

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

@@ -348,6 +348,7 @@ object Feature:
         true
       case `magic` =>
         ctx.compilationUnit.magic = true
+        ctx.compilationUnit.sourceVersion = Some(SourceVersion.future)
         true
       case `inlineTraits` =>
         ctx.compilationUnit.knowsInlineTraits = true

tests/neg/i1793-maybe.scala

@@ -4,6 +4,6 @@ object Test {
   import scala.ref.WeakReference
   def unapply[T <: AnyVal](wr: WeakReference[T]): T? = {
     val x = wr.underlying.get
-    if (x != null) x else null // error
+    if x != null then x else null // error
   }
 }

tests/neg/i2378-maybe.scala

@@ -14,13 +14,13 @@ trait Toolbox {
 
   trait ApplyImpl {
     def unapply(tree: Tree): (Tree, Seq[Tree])?
-    def unapply(tree: tpd.Tree)(implicit c: Cap): (tpd.Tree, Seq[tpd.Tree])?
+    def unapply(tree: tpd.Tree)(using c: Cap): (tpd.Tree, Seq[tpd.Tree])?
   }
 }
 
 class Test(val tb: Toolbox) {
   import tb.*
-  implicit val cap: Cap = null.asInstanceOf[Cap]
+  given cap: Cap = null.asInstanceOf[Cap]
 
   def foo(tree: Tree): Int = (tree: Any) match {
     case tb.Apply(fun, args) => 3  // error: ambiguous overload of unapply

tests/neg/patmat2-maybe.scala

@@ -6,7 +6,7 @@ import java.lang.IllegalArgumentException
 
 object IAE {
   def unapply(e: Exception): String? =
-    if (e.isInstanceOf[IllegalArgumentException]) e.getMessage
+    if e.isInstanceOf[IllegalArgumentException] then e.getMessage
     else null
 }
 

tests/neg/refutable-pattern-binding-messages-maybe.check

@@ -1,3 +1,11 @@
+-- Error: tests/neg/refutable-pattern-binding-messages-maybe.scala:6:14 ------------------------------------------------
+6 |  val Positive(p) = 5                     // error: refutable extractor
+  |      ^^^^^^^^^^^^^^^
+  |      pattern binding uses refutable extractor `Test.Positive`
+  |
+  |      If this usage is intentional, this can be communicated by adding `.runtimeChecked` after the expression,
+  |      which may result in a MatchError at runtime.
+  |      This patch can be rewritten automatically under -rewrite -source 3.8-migration.
 -- Error: tests/neg/refutable-pattern-binding-messages-maybe.scala:7:14 ------------------------------------------------
 7 |  for Positive(i) <- List(1, 2, 3) do ()  // error: refutable extractor
   |      ^^^^^^^^^^^
@@ -6,6 +14,14 @@
   |      If this usage is intentional, this can be communicated by adding the `case` keyword before the full pattern,
   |      which will result in a filtering for expression (using `withFilter`).
   |      This patch can be rewritten automatically under -rewrite -source 3.2-migration.
+-- Error: tests/neg/refutable-pattern-binding-messages-maybe.scala:11:20 -----------------------------------------------
+11 |  val i :: is = List(1, 2, 3)             // error: pattern type more specialized
+   |                ^^^^^^^^^^^^^
+   |     pattern's type ::[Int] is more specialized than the right hand side expression's type List[Int]
+   |
+   |     If the narrowing is intentional, this can be communicated by adding `.runtimeChecked` after the expression,
+   |     which may result in a MatchError at runtime.
+   |     This patch can be rewritten automatically under -rewrite -source 3.8-migration.
 -- Error: tests/neg/refutable-pattern-binding-messages-maybe.scala:12:11 -----------------------------------------------
 12 |  for ((x: String) <- xs) do ()           // error: pattern type more specialized
    |           ^^^^^^
@@ -22,24 +38,8 @@
    | If the narrowing is intentional, this can be communicated by adding the `case` keyword before the full pattern,
    | which will result in a filtering for expression (using `withFilter`).
    | This patch can be rewritten automatically under -rewrite -source 3.2-migration.
--- Warning: tests/neg/refutable-pattern-binding-messages-maybe.scala:6:14 ----------------------------------------------
-6 |  val Positive(p) = 5                     // warn: refutable extractor
-  |      ^^^^^^^^^^^^^^^
-  |      pattern binding uses refutable extractor `Test.Positive`
-  |
-  |      If this usage is intentional, this can be communicated by adding `.runtimeChecked` after the expression,
-  |      which may result in a MatchError at runtime.
-  |      This patch can be rewritten automatically under -rewrite -source 3.8-migration.
--- Warning: tests/neg/refutable-pattern-binding-messages-maybe.scala:11:20 ---------------------------------------------
-11 |  val i :: is = List(1, 2, 3)             // warn: pattern type more specialized
-   |                ^^^^^^^^^^^^^
-   |     pattern's type ::[Int] is more specialized than the right hand side expression's type List[Int]
-   |
-   |     If the narrowing is intentional, this can be communicated by adding `.runtimeChecked` after the expression,
-   |     which may result in a MatchError at runtime.
-   |     This patch can be rewritten automatically under -rewrite -source 3.8-migration.
--- Warning: tests/neg/refutable-pattern-binding-messages-maybe.scala:17:10 ---------------------------------------------
-17 |  val 1 = 2                               // warn: pattern type does not match
+-- Error: tests/neg/refutable-pattern-binding-messages-maybe.scala:17:10 -----------------------------------------------
+17 |  val 1 = 2                               // error: pattern type does not match
    |          ^
    |     pattern's type (1 : Int) does not match the right hand side expression's type (2 : Int)
    |

tests/neg/refutable-pattern-binding-messages-maybe.scala

@@ -1,18 +1,18 @@
-//> using options -source 3.8 -Yexplicit-nulls
+//> using options -Yexplicit-nulls
 import language.experimental.magic
 object Test {
   // refutable extractor
   object Positive { def unapply(i: Int): Int? = if i > 0 then i else null }
-  val Positive(p) = 5                     // warn: refutable extractor
+  val Positive(p) = 5                     // error: refutable extractor
   for Positive(i) <- List(1, 2, 3) do ()  // error: refutable extractor
 
   // more specialized
   val xs: List[AnyRef] = ???
-  val i :: is = List(1, 2, 3)             // warn: pattern type more specialized
+  val i :: is = List(1, 2, 3)             // error: pattern type more specialized
   for ((x: String) <- xs) do ()           // error: pattern type more specialized
 
   // does not match
   val ys: List[Option[?]] = ???
   for none @ None <- ys do ()             // error: pattern type does not match
-  val 1 = 2                               // warn: pattern type does not match
+  val 1 = 2                               // error: pattern type does not match
 }

tests/neg/unchecked-patterns-maybe.scala

@@ -6,24 +6,23 @@ object Test {
   val (y1: Some[Int]) = Some(1): Option[Int] @unchecked  // OK
   val y2: Some[Int] @unchecked = Some(1): Option[Int]    // error
 
-  val x :: xs = List(1, 2, 3)        // warn
-  val (1, c) = (1, 2)                // warn
-  val 1 *: cs = 1 *: Tuple()         // warn
+  val x :: xs = List(1, 2, 3)        // error
+  val (1, c) = (1, 2)                // error
+  val 1 *: cs = 1 *: Tuple()         // error
 
-  val (_: Int | _: AnyRef) = ??? : AnyRef  // warn
+  val (_: Int | _: AnyRef) = ??? : AnyRef  // error
 
-  val 1 = 2  // warn
+  val 1 = 2  // error
 
   object Positive { def unapply(i: Int): Int? = if i > 0 then i else null }
   object Always1 { def unapply(i: Int): Some[Int] = Some(i) }
   object Pair { def unapply(t: (Int, Int)): t.type = t }
   object Triple { def unapply(t: (Int, Int, Int)): (Int, Int, Int) = t }
 
-  val Positive(p) = 5                // warn
-  val Some(s1) = Option(1)           // warn
+  val Positive(p) = 5                // error
+  val Some(s1) = Option(1)           // error
   val Some(s2) = Some(1)             // OK
   val Always1(p1) = 5                // OK
   val Pair(t1, t2) = (5, 5)          // OK
   val Triple(u1, u2, u3) = (5, 5, 5) // OK
 }
-// nopos-error: No warnings can be incurred under -Werror (or -Xfatal-warnings)

tests/new/test.scala

@@ -1,4 +1,5 @@
 import language.experimental.magic
+import language.future
 import scala.magic.*
 import scala.util.Either
 
@@ -11,4 +12,5 @@ object Extract:
   def unapply[T](x: T): T ? String = Ok(x)
 
 @main def Test = 22 match
-  case Extract(s) => println(s)
+  case Extract(s) =>
+    if (true) println(s)

tests/patmat/optionless-maybe.check

@@ -1,6 +1,6 @@
--- [E029] Pattern Match Exhaustivity Warning: tests/patmat/optionless-maybe.scala:30:44 
-30 |  def qux(t: Tree)(implicit c: Cap): Unit = t match {
-   |                                            ^
+-- [E029] Pattern Match Exhaustivity Warning: tests/patmat/optionless-maybe.scala:30:41 
+30 |  def qux(t: Tree)(using c: Cap): Unit = t match {
+   |                                         ^
    |                                 match may not be exhaustive.
    |
    |                                 It would fail on pattern case: Ident(_)

tests/patmat/optionless-maybe.scala

@@ -9,11 +9,11 @@ object Ident1 {
 
 trait Cap
 object Ident2 {
-  def unapply(tree: Tree)(implicit any: Cap): Ident = ???
+  def unapply(tree: Tree)(using any: Cap): Ident = ???
 }
 
 object Ident3 {
-  def unapply(tree: Tree)(implicit any: Cap): Ident? = ???
+  def unapply(tree: Tree)(using any: Cap): Ident? = ???
 }
 
 
@@ -23,11 +23,11 @@ class Test {
     case Ident1(t) =>
   }
 
-  def bar(t: Tree)(implicit c: Cap): Unit = t match {
+  def bar(t: Tree)(using c: Cap): Unit = t match {
     case Ident2(t) =>
   }
 
-  def qux(t: Tree)(implicit c: Cap): Unit = t match {
+  def qux(t: Tree)(using c: Cap): Unit = t match {
     case Ident3(t) =>
   }