Update tests and restore parsing for infix ^ in types

Author: odersky

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

@@ -1689,6 +1689,7 @@ object Parsers {
       if in.token == LPAREN then funParamClause() :: funParamClauses() else Nil
 
     /** InfixType ::= RefinedType {id [nl] RefinedType}
+     *             |  RefinedType `^`
      */
     def infixType(): Tree = infixTypeRest(refinedType())
 
@@ -1708,7 +1709,13 @@ object Parsers {
         refinedTypeRest(atSpan(startOffset(t)) {
           RefinedTypeTree(rejectWildcardType(t), refinement(indentOK = true))
         })
-      else if in.isIdent(nme.UPARROW) then
+      else if in.isIdent(nme.UPARROW)
+          && (in.lookahead.token == LBRACE
+              || !canStartInfixTypeTokens.contains(in.lookahead.token))
+        // Disambiguation: a `^` is treated as a postfix operator meaning `^{any}`
+        // if followed by `{` or newline, or any other token that cannot start
+        // an infix type. Otherwise it is treated as an infix operator.
+      then
         val upArrowStart = in.offset
         in.nextToken()
         def cs =

tests/pos-custom-args/captures/byname.scala

@@ -1,12 +1,12 @@
 import annotation.retainsByName
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 class I
 
-def test(cap1: Cap, cap2: Cap): I{ref cap1} =
+def test(cap1: Cap, cap2: Cap): I^{cap1} =
   def f() = if cap1 == cap1 then I() else I()
-  def h(x: ->{ref any} I) = x
+  def h(x: ->{any} I) = x
   h(f()) // OK
   def hh(x: -> I @retainsByName(cap1)) = x
   h(f())

tests/pos-custom-args/captures/capt-test.scala

@@ -19,10 +19,10 @@ def map[A, B](f: A => B)(xs: LIST[A]): LIST[B] =
   xs.map(f)
 
 class C
-type Cap = C{ref any}
+type Cap = C^
 
 class Foo(x: Cap):
-  this: Foo{ref x} =>
+  this: Foo^{x} =>
 
 def test(c: Cap, d: Cap) =
   def f(x: Cap): Unit = if c == x then ()
@@ -32,7 +32,7 @@ def test(c: Cap, d: Cap) =
   val zs =
     val z = g
     CONS(z, ys)
-  val zsc: LIST[Cap ->{ref d, y} Unit] = zs
+  val zsc: LIST[Cap ->{d, y} Unit] = zs
 
   val a4 = zs.map(identity)
-  val a4c: LIST[Cap ->{ref d, y} Unit] = a4
+  val a4c: LIST[Cap ->{d, y} Unit] = a4

tests/pos-custom-args/captures/classes.scala

@@ -1,22 +1,22 @@
 import annotation.retains
 class B
-type Cap = B{ref any}
+type Cap = B^
 class C(val n: Cap):
-  this: C{ref n} =>
-  def foo(): B{ref n} = n
+  this: C^{n} =>
+  def foo(): B^{n} = n
 
 
 def test(x: Cap, y: Cap, z: Cap) =
   val c0 = C(x)
-  val c1: C{ref x}{val n: B{ref x}} = c0
+  val c1: C{val n: B^{x}}^{x} = c0
   val d = c1.foo()
-  d: B{ref x}
+  d: B^{x}
 
   val c2 = if ??? then C(x) else C(y)
   val c2a = identity(c2)
-  val c3: C{ref x, y}{ val n: B{ref x, y} } = c2
+  val c3: C{ val n: B^{x, y} }^{x, y} = c2
   val d1 = c3.foo()
-  d1: B{ref x, y}
+  d1: B^{x, y}
 
   class Local:
 
@@ -29,7 +29,7 @@ def test(x: Cap, y: Cap, z: Cap) =
   end Local
 
   val l = Local()
-  val l1: Local{ref x, y} = l
+  val l1: Local^{x, y} = l
   val l2 = Local(x)
-  val l3: Local{ref x, y, z} = l2
+  val l3: Local^{x, y, z} = l2
 

tests/run-custom-args/captures/colltest5/Test_2.scala

@@ -5,7 +5,7 @@ object Test {
   import colltest5.strawman.collections.*
   import CollectionStrawMan5.*
 
-  def seqOps(xs: Seq[Int]) = { // try with Seq[Int]{ref any}
+  def seqOps(xs: Seq[Int]) = { // try with Seq[Int]^{any}
     val strPlusInt: (String, Int) => String = _ + _
     val intPlusStr: (Int, String) => String = _ + _
     val isEven: Int => Boolean = _ % 2 == 0
@@ -61,7 +61,7 @@ object Test {
     println(xs16)
   }
 
-  def viewOps(xs: View[Int]{ref any}) = {
+  def viewOps(xs: View[Int]^{any}) = {
     val strPlusInt: (String, Int) => String = _ + _
     val intPlusStr: (Int, String) => String = _ + _
     val isEven: Int => Boolean = _ % 2 == 0
@@ -78,27 +78,27 @@ object Test {
     val x5 = xs.to(List)
     val y5: List[Int] = x5
     val (xs6, xs7) = xs.partition(isEven)
-    val ys6: View[Int]{ref xs6, isEven} = xs6
-    val ys7: View[Int]{ref xs7, isEven} = xs7
+    val ys6: View[Int]^{xs6, isEven} = xs6
+    val ys7: View[Int]^{xs7, isEven} = xs7
     val (xs6a, xs7a) = xs.partition(_ % 2 == 0)
-    val ys6a: View[Int]{ref xs6} = xs6
-    val ys7a: View[Int]{ref xs7} = xs7
+    val ys6a: View[Int]^{xs6} = xs6
+    val ys7a: View[Int]^{xs7} = xs7
     val xs8 = xs.drop(2)
-    val ys8: View[Int]{ref xs8} = xs8
+    val ys8: View[Int]^{xs8} = xs8
     val xs9 = xs.map(isNonNeg)
-    val ys9: View[Boolean]{ref xs9} = xs9
+    val ys9: View[Boolean]^{xs9} = xs9
     val xs10 = xs.flatMap(flips)
-    val ys10: View[Int]{ref xs10} = xs10
+    val ys10: View[Int]^{xs10} = xs10
     val xs11 = xs ++ xs
-    val ys11: View[Int]{ref xs11} = xs11
+    val ys11: View[Int]^{xs11} = xs11
     val xs12 = xs ++ Nil
-    val ys12: View[Int]{ref xs12} = xs12
+    val ys12: View[Int]^{xs12} = xs12
     val xs13 = Nil ++ xs
     val ys13: List[Int] = xs13
     val xs14 = xs ++ Cons("a", Nil)
-    val ys14: View[Any]{ref xs14} = xs14
+    val ys14: View[Any]^{xs14} = xs14
     val xs15 = xs.zip(xs9)
-    val ys15: View[(Int, Boolean)]{ref xs15} = xs15
+    val ys15: View[(Int, Boolean)]^{xs15} = xs15
     println("-------")
     println(x1)
     println(x2)