Switch to postfix as for patterns

Author: odersky

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

@@ -630,7 +630,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             }
         }
         compareTypeLambda
-      case tp2 as OrType(tp21, tp22) =>
+      case tp2 @ OrType(tp21, tp22) =>
         compareAtoms(tp1, tp2) match
           case Some(b) => return b
           case _ =>
@@ -970,7 +970,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
        *  corresponding arguments are subtypes relative to their variance (see `isSubArgs`).
        */
       def isMatchingApply(tp1: Type): Boolean = tp1 match {
-        case tp1 as AppliedType(tycon1, args1) =>
+        case tp1 @ AppliedType(tycon1, args1) =>
           // We intentionally do not automatically dealias `tycon1` or `tycon2` here.
           // `TypeApplications#appliedTo` already takes care of dealiasing type
           // constructors when this can be done without affecting type

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

@@ -150,7 +150,7 @@ object TypeOps:
         tp.derivedAlias(simplify(tp.alias, theMap))
       case AndType(l, r) if !ctx.mode.is(Mode.Type) =>
         simplify(l, theMap) & simplify(r, theMap)
-      case tp as OrType(l, r)
+      case tp @ OrType(l, r)
       if !ctx.mode.is(Mode.Type)
          && (tp.isSoft || l.isBottomType || r.isBottomType) =>
         // Normalize A | Null and Null | A to A even if the union is hard (i.e.

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

@@ -2657,12 +2657,12 @@ object Parsers {
         ascription(p, location)
       else p
 
-    /**  Pattern2    ::=  [id `as'] InfixPattern
+    /**  Pattern2    ::=  InfixPattern [`as' id]
      */
-    val pattern2: () => Tree = () => infixPattern() match {
-      case p @ Ident(name) if in.token == AT || in.isIdent(nme.as) =>
-        if in.token == AT && sourceVersion.isAtLeast(`3.1`) then
-          deprecationWarning(s"`@` bindings have been deprecated; use `as` instead", in.offset)
+    val pattern2: () => Tree = () => infixPattern() match
+      case p @ Ident(name) if in.token == AT =>
+        if sourceVersion.isAtLeast(`3.1`) then
+          deprecationWarning(s"`<name> @ <pattern>` bindings have been deprecated; use `<apttern> as <name>` instead", in.offset)
 
         val offset = in.skipToken()
         infixPattern() match {
@@ -2678,8 +2678,18 @@ object Parsers {
         warnMigration(p)
         atSpan(startOffset(p)) { Typed(Ident(nme.WILDCARD), p) }
       case p =>
-        p
-    }
+        if in.isIdent(nme.as) then
+          in.nextToken()
+          atSpan(startOffset(p), in.offset) {
+            p match
+              case p @ Bind(nme.WILDCARD, pt: Typed) if p.mods.is(Given) =>
+                Bind(ident(), pt).withMods(p.mods)
+              case _ =>
+                Bind(ident(), p)
+          }
+        else
+          p
+    end pattern2
 
     private def warnMigration(p: Tree) =
       if sourceVersion.isAtLeast(`3.1`) then

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -214,7 +214,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       // of AndType and OrType to account for associativity
       case AndType(tp1, tp2) =>
         toTextInfixType(tpnme.raw.AMP, tp1, tp2) { toText(tpnme.raw.AMP) }
-      case tp as OrType(tp1, tp2) =>
+      case tp @ OrType(tp1, tp2) =>
         toTextInfixType(tpnme.raw.BAR, tp1, tp2) {
           if tp.isSoft && printDebug then toText(tpnme.ZOR) else toText(tpnme.raw.BAR)
         }

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -480,7 +480,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
           else args.map(arg => erase(arg, inArray = false))
         tp.derivedAppliedType(erase(tycon, inArray), args2)
 
-      case tp as OrType(tp1, tp2) =>
+      case tp @ OrType(tp1, tp2) =>
         OrType(erase(tp1, inArray), erase(tp2, inArray), tp.isSoft)
 
       case AndType(tp1, tp2) =>

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

@@ -600,7 +600,7 @@ trait Applications extends Compatibility {
             args match {
               case arg :: Nil if isVarArg(arg) =>
                 addTyped(arg, formal)
-              case (arg as Typed(Literal(Constant(null)), _)) :: Nil if ctx.isAfterTyper =>
+              case (arg @ Typed(Literal(Constant(null)), _)) :: Nil if ctx.isAfterTyper =>
                 addTyped(arg, formal)
               case _ =>
                 val elemFormal = formal.widenExpr.argTypesLo.head

docs/docs/internals/syntax.md

@@ -268,8 +268,7 @@ TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
 TypeCaseClause    ::=  ‘case’ InfixType ‘=>’ Type [nl]
 
 Pattern           ::=  Pattern1 { ‘|’ Pattern1 }                                Alternative(pats)
-Pattern1          ::=  Pattern2 [‘:’ RefinedType]                               Bind(name, Typed(Ident(wildcard), tpe))
-Pattern2          ::=  [id ‘as’] InfixPattern                                   Bind(name, pat)
+Pattern1          ::=  InfixPattern [‘as’ id] [‘:’ RefinedType]                 Bind(name, pat), Bind(name, Typed(Ident(wildcard), tpe))
 InfixPattern      ::=  SimplePattern { id [nl] SimplePattern }                  InfixOp(pat, op, pat)
 SimplePattern     ::=  PatVar                                                   Ident(wildcard)
                     |  Literal                                                  Bind(name, Ident(wildcard))

docs/docs/reference/contextual/given-imports.md

@@ -61,9 +61,9 @@ For instance, assuming the object
 ```scala
 object Instances {
   given Ordering[Int] as intOrd
-  given listOrd[T: Ordering] as Ordering[List[T]]
-  given ec as ExecutionContext = ...
-  given im as Monoid[Int]
+  given [T: Ordering] => Ordering[List[T]] as listOrd
+  given ExecutionContext as ec = ...
+  given Monoid[Int] as im
 }
 ```
 

library/src/scala/quoted/ExprMap.scala

@@ -47,7 +47,7 @@ trait ExprMap:
           tree
         case Super(qual, mix) =>
           tree
-        case tree as Apply(fun, args) =>
+        case tree @ Apply(fun, args) =>
           val MethodType(_, tpes, _) = fun.tpe.widen
           Apply.copy(tree)(transformTerm(fun, TypeRepr.of[Any])(owner), transformTerms(args, tpes)(owner))
         case TypeApply(fun, args) =>

scala3doc-testcases/src/tests/implicitConversions2.scala

@@ -29,7 +29,7 @@ class OuterClass //unexpected
       = ???
   }
 
-  given conversionFromVal as Conversion[ClassWithConversionFromVal, Methods] //unexpected
+  given Conversion[ClassWithConversionFromVal, Methods] as conversionFromVal //unexpected
   {
     def apply(a: ClassWithConversionFromVal): Methods //unexpected
     = ???

tests/init/crash/fors.scala

@@ -26,7 +26,7 @@ object Test extends App {
     var n = 0
     for (_ <- xs) n += 1; println(n)
     for ((x, y) <- xs zip ys) print(x + " "); println()
-    for (p as (x, y) <- xs zip ys) print(p._1 + " "); println()
+    for ((x, y) as p <- xs zip ys) print(p._1 + " "); println()
 
     // iterators
     for (x <- it) print(x + " "); println()
@@ -53,7 +53,7 @@ object Test extends App {
     var n = 0
     for (_ <- xs) n += 1; println(n)
     for ((x, y) <- xs zip ys) print(x + " "); println()
-    for (p as (x, y) <- xs zip ys) print(p._1 + " "); println()
+    for ((x, y) as p <- xs zip ys) print(p._1 + " "); println()
 
     // iterators
     for (x <- it) print(x + " "); println()

tests/neg/Iter3.scala

@@ -147,7 +147,7 @@ object Iter2 {
       flatten(map(f(_).buildIterator))
 
     override def ++[B >: A](that: IterableOnce[B]): ArrayIterator[B] = {
-      val thatIterator as ArrayIterator(elems2, len2) = fromIterator(that.iterator)
+      val ArrayIterator(elems2, len2) as thatIterator = fromIterator(that.iterator)
       if (len == 0) thatIterator
       else if (len2 == 0) this.asInstanceOf[ArrayIterator[B]]
       else {

tests/neg/ensureReported.scala

@@ -1,6 +1,6 @@
 object AnonymousF {
   val f = {
-    case l as List(1) => // error: missing parameter type
+    case List(1) as l => // error: missing parameter type
       Some(l)
   }
 }

tests/neg/i1716.scala

@@ -1,7 +1,7 @@
 object Fail {
   def f(m: Option[Int]): Unit = {
      m match {
-      case x as Some[_] =>       // error: unbound wildcard type
+      case Some[_] as x =>       // error: unbound wildcard type
       case _           =>
     }
   }

tests/neg/i3200.scala

@@ -1,6 +1,6 @@
 object Test {
   case object Bob { override def equals(other: Any) = true }
   def main(args: Array[String]): Unit = {
-    val m : Bob.type = (5: Any) match { case x as Bob => x }  // error
+    val m : Bob.type = (5: Any) match { case Bob as x => x }  // error
   }
 }

tests/neg/i3200b.scala

@@ -1,8 +1,8 @@
 object Test {
   def main(args: Array[String]): Unit = {
-    val a: Nil.type = (Vector(): Any) match { case n as Nil => n } // error
-    val b: Nil.type = (Vector(): Any) match { case n as (m as Nil) => n } // error
-    val c: Int = (1.0: Any) match { case n as 1 => n } // error
-    val d: Int = (1.0: Any) match { case n as (m as 1) => n } // error
+    val a: Nil.type = (Vector(): Any) match { case Nil as n => n } // error
+    val b: Nil.type = (Vector(): Any) match { case (Nil as m) as n => n } // error
+    val c: Int = (1.0: Any) match { case 1 as n => n } // error
+    val d: Int = (1.0: Any) match { case (1 as m) as n => n } // error
   }
 }

tests/neg/i3332.scala

@@ -16,6 +16,6 @@ object Test {
     case _ => println("nope")
   }
   def test(x: Any) = x match {
-    case _: String | _ as A() => 1
+    case _: String | A() => 1
   }
 }

tests/neg/i3812b.scala

@@ -19,9 +19,9 @@ object Test {
     Some(x) match { case Some(Z2.v)  => () } // ok
 
     Some(x) match { case Some(4) | Some(Z1.v) => () } // error
-    Some(x) match { case a as Some(Z1.v)       => () } // error
+    Some(x) match { case Some(Z1.v) as a => () } // error
 
     Some(x) match { case Some(4) | Some(Z2.v) => () } // ok
-    Some(x) match { case a as Some(Z2.v)       => () } // ok
+    Some(x) match { case Some(Z2.v) as a => () } // ok
   }
 }

tests/neg/i8407.scala

@@ -1,6 +1,6 @@
 object Test:
   val xs = List(1, 2, 3, 4, 5)
   xs match {
-    case List(1, 2, xs1 as xs2: _*) => println(xs2) // error // error
+    case List(1, 2, xs2 as xs1: _*) => println(xs2) // error // error
     case _ => ()
   }

tests/neg/i8715.scala

@@ -1,2 +1,2 @@
 @main
-def Test = List(42) match { case List(xs as (ys: _*)) => xs }  // error
+def Test = List(42) match { case List((ys: _*) as xs) => xs }  // error

tests/neg/i9310.scala

@@ -1,5 +1,5 @@
 //AE-d101cfe6d25117a51897609e673f6c8e74d31e6e
-val foo as this = 0
+val this as foo = 0
 class Foo {
   foo { } // error
 }

tests/neg/multi-patterns.scala

@@ -1,4 +1,4 @@
 object Test {
   val (a :: as), bs = List(1, 2, 3) // error
-  val B as List(), C: List[Int] = List() // error
+  val List() as B, C: List[Int] = List() // error
 }

tests/neg/patternUnsoundness.scala

@@ -10,7 +10,7 @@ object patternUnsoundness extends App {
   val y: C[Object] = x
 
   y match {
-    case d as D(x) => d.s = new Integer(1) // error
+    case D(x) as d => d.s = new Integer(1) // error
   }
 
   val z: String = x.s // used to throw ClassCast exception

tests/patmat/i7186.scala

@@ -118,7 +118,7 @@ object printMips {
             s"$indent.globl $id$endl"
           case Label(Scoped(Identifier(i),-1)) =>
             s"$i:$endl"
-          case Label(s @ Scoped(Identifier(i), id)) =>
+          case Label(Scoped(Identifier(i), id) as s) =>
             s"${getScopedLabel(s)}: #debug: $i~$id$endl"
           case ControlLabel(id) =>
             s"${evalLabels(id)}:$endl"

tests/pos-macros/i6535/Macro_1.scala

@@ -10,7 +10,7 @@ object scalatest {
     import ValDef.let
 
     Term.of(cond).underlyingArgument match {
-      case t @ Apply(Select(lhs, op), rhs :: Nil) =>
+      case Apply(Select(lhs, op), rhs :: Nil) as t =>
         let(Symbol.spliceOwner, lhs) { left =>
           let(Symbol.spliceOwner, rhs) { right =>
             val app = Select.overloaded(left, op, Nil, right :: Nil)

tests/pos-macros/quoted-pattern-type.scala

@@ -4,39 +4,39 @@ object Lib {
 
   def impl[T: Type](arg: Expr[T])(using Quotes): Expr[T] = {
     arg match {
-      case e @ '{ $x: Boolean } =>
+      case '{ $x: Boolean } as e =>
         e: Expr[T & Boolean]
         x: Expr[T & Boolean]
         e
 
-      case e @ '{ println("hello"); $x } =>
+      case '{ println("hello"); $x } as e =>
         e: Expr[T]
         x: Expr[T]
         e
 
-      case e @ '{ println("hello"); $x: T } =>
+      case '{ println("hello"); $x: T } as e =>
         e: Expr[T]
         x: Expr[T]
         e
 
-      case e @ '{ Some($x: Int) } =>
+      case '{ Some($x: Int) } as e =>
         e: Expr[T & Some[Int]]
         x: Expr[Int]
         e
 
-      case e @ '{ if ($x) ($y: Boolean) else ($z: Int) } =>
+      case '{ if ($x) ($y: Boolean) else ($z: Int) } as e =>
         e: Expr[T & (Boolean | Int)]
         y: Expr[T & Boolean]
         z: Expr[T & Int]
         e
 
-      case e @ '{ if ($x) $y else $z } =>
+      case '{ if ($x) $y else $z } as e =>
         e: Expr[T]
         y: Expr[T]
         z: Expr[T]
         e
 
-      case e @ '{ if ($x) $y else ($z: Int) } =>
+      case '{ if ($x) $y else ($z: Int) } as e =>
         e: Expr[T & (T | Int)]
         y: Expr[T]
         z: Expr[T & Int]

tests/pos-special/strawman-collections/CollectionStrawMan1.scala

@@ -190,7 +190,7 @@ object CollectionStrawMan1 {
         Array.copy(fst.elems, fst.start, elems, 0, fst.remaining)
         Array.copy(snd.elems, snd.start, elems, fst.remaining, snd.remaining)
         new ArrayBuffer(elems, elems.length)
-      case it @ Iterator.Partition(underlying, _, buf, _) =>
+      case Iterator.Partition(underlying, _, buf, _) as it =>
         while (underlying.hasNext) it.distribute()
         buf.asInstanceOf[ArrayBuffer[B]]
       case it if it.remaining >= 0 =>

tests/pos-special/strawman-collections/CollectionStrawMan4.scala

@@ -216,7 +216,7 @@ object CollectionStrawMan4 {
 
   object ListBuffer extends IterableFactory[ListBuffer] {
     def fromIterable[B](coll: Iterable[B]): ListBuffer[B] = coll match {
-      case pd @ View.Partitioned(partition: View.Partition[B] @unchecked) =>
+      case View.Partitioned(partition: View.Partition[B] @unchecked) as pd =>
         partition.distribute(new ListBuffer[B]())
         new ListBuffer[B] ++= pd.forced.get
       case _ =>
@@ -267,7 +267,7 @@ object CollectionStrawMan4 {
         Array.copy(fst.elems, fst.start, elems, 0, fst.length)
         Array.copy(snd.elems, snd.start, elems, fst.length, snd.length)
         new ArrayBuffer(elems, elems.length)
-      case pd @ View.Partitioned(partition: View.Partition[B] @unchecked) =>
+      case View.Partitioned(partition: View.Partition[B] @unchecked) as pd =>
         partition.distribute(new ArrayBuffer[B]())
         pd.forced.get.asInstanceOf[ArrayBuffer[B]]
       case c if c.knownLength >= 0 =>

tests/pos-with-compiler/Patterns.scala

@@ -13,7 +13,7 @@ object Patterns {
   }
   d match {
     case WildcardType(bounds: TypeBounds) => bounds.lo
-    case a @ Assign(Ident(id), rhs) => id
+    case Assign(Ident(id), rhs) as a => id
     case a: Object => a
   }
 
@@ -42,7 +42,7 @@ object Patterns {
       case List(x, z) => x
       case List(x) => x
       case List() => ""
-      case x @ _ => "wildcard"
+      case _ as x => "wildcard"
     }
     val yy: String = y
   }

tests/pos/Iter2.scala

@@ -193,7 +193,7 @@ object Iter2 {
       flatten(map(f(_).buildIterator))
 
     override def ++[B >: A](that: IterableOnce[B]): ArrayIterator[B] = {
-      val thatIterator as ArrayIterator(elems2, len2) = fromIterator(that.iterator)
+      val ArrayIterator(elems2, len2) as thatIterator = fromIterator(that.iterator)
       if (len == 0) thatIterator
       else if (len2 == 0) this
       else {

tests/pos/given-pattern.scala

@@ -6,17 +6,17 @@ class Test {
   transparent inline def trySummon[S, T](f: PartialFunction[S, T]): T = ???
 
   inline def setFor[T]: Set[T] = trySummon {
-    case ord as given Ordering[T] => new TreeSet[T]
+    case given Ordering[T] as ord => new TreeSet[T]
     case given Ordering[T]        => new TreeSet[T]
     case _                        => new HashSet[T]
   }
 
   def f1[T](x: Ordering[T]) = (x, x) match {
-    case (y as given Ordering[T], _) => new TreeSet[T]
+    case (given Ordering[T] as y, _) => new TreeSet[T]
   }
   def f2[T](x: Ordering[T]) = {
     val xs = List(x, x, x)
-    for y as given Ordering[T] <- xs
+    for given Ordering[T] as y <- xs
     yield new TreeSet[T]
   }
   def f3[T](x: Ordering[T]) = (x, x) match {