Update bootstrap library to new syntax

Author: odersky

docs/docs/reference/other-new-features/principled-meta-programming.md

@@ -783,7 +783,7 @@ implementation of power otherwise.
 This assumes a `Constant` extractor that maps tree nodes representing
 constants to their values.
 
-With the right extractors, the "AsFunction" operation
+With the right extractors, the "AsFunction" conversion
 that maps expressions over functions to functions over expressions can
 be implemented in user code:
 ```scala

docs/docs/reference/other-new-features/tasty-reflect.md

@@ -24,7 +24,7 @@ To provide reflection capabilities in macros we need to add an implicit paramete
 import scala.quoted._
 import scala.tasty._
 
-inline def natConst(x: Int): Int = ~natConstImpl('(x))
+inline def natConst(x: Int): Int = ~natConstImpl('{x})
 
 def natConstImpl(x: Expr[Int])(implicit reflection: Reflection): Expr[Int] = {
   import reflection._

library/src-bootstrapped/scala/StagedTuple.scala

@@ -10,7 +10,7 @@ sealed trait Tuple extends Any {
     if (stageIt) stagedToArray
     else inline constValueOpt[BoundedSize[this.type]] match {
       case Some(0) =>
-        $emptyArray
+        empty$Array
       case Some(1) =>
         val t = asInstanceOf[Tuple1[Object]]
         Array(t._1)
@@ -24,15 +24,15 @@ sealed trait Tuple extends Any {
         val t = asInstanceOf[Tuple4[Object, Object, Object, Object]]
         Array(t._1, t._2, t._3, t._4)
       case Some(n) if n <= $MaxSpecialized =>
-        $toArray(this, n)
+        to$Array(this, n)
       case Some(n) =>
         asInstanceOf[TupleXXL].elems
       case None =>
         dynamicToArray(this)
     }
 
   inline def stagedToArray: Array[Object] =
-    ~StagedTuple.toArrayStaged('(this), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.toArrayStaged('{this}, constValueOpt[BoundedSize[this.type]]) }
 
   inline def *: [H] (x: H): H *: this.type =
     if (stageIt) stagedCons[H](x)
@@ -53,14 +53,14 @@ sealed trait Tuple extends Any {
           val t = asInstanceOf[Tuple4[_, _, _, _]]
           Tuple5(x, t._1, t._2, t._3, t._4).asInstanceOf[Result]
         case Some(n) =>
-          fromArray[Result]($consArray(x, toArray))
+          fromArray[Result](cons$Array(x, toArray))
         case _ =>
           dynamic_*:[this.type, H](this, x)
       }
     }
 
   inline def stagedCons[H] (x: H): H *: this.type =
-    ~StagedTuple.stagedCons('(this), '(x), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.stagedCons('{this}, '{x}, constValueOpt[BoundedSize[this.type]]) }
 
   inline def ++(that: Tuple): Concat[this.type, that.type] =
     if (stageIt) stagedConcat(that)
@@ -104,8 +104,8 @@ sealed trait Tuple extends Any {
     }
 
   inline def stagedConcat(that: Tuple): Concat[this.type, that.type] =
-    ~StagedTuple.stagedConcat('(this), constValueOpt[BoundedSize[this.type]],
-                              '(that), constValueOpt[BoundedSize[that.type]])
+    ${ StagedTuple.stagedConcat('{this}, constValueOpt[BoundedSize[this.type]],
+                                '{that}, constValueOpt[BoundedSize[that.type]]) }
 
   inline def genericConcat[T <: Tuple](xs: Tuple, ys: Tuple): Tuple =
     fromArray[T](xs.toArray ++ ys.toArray)
@@ -121,7 +121,7 @@ sealed trait Tuple extends Any {
     }
 
   inline def stagedSize: Size[this.type] =
-    ~StagedTuple.sizeStaged[Size[this.type]]('(this), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.sizeStaged[Size[this.type]]('{this}, constValueOpt[BoundedSize[this.type]]) }
 }
 
 object Tuple {
@@ -167,9 +167,9 @@ object Tuple {
 
   private[scala] type BoundedSize[X] = BoundedSizeRecur[X, 23]
 
-  val $emptyArray = Array[Object]()
+  val empty$Array = Array[Object]()
 
-  def $toArray(xs: Tuple, n: Int) = {
+  def to$Array(xs: Tuple, n: Int) = {
     val arr = new Array[Object](n)
     var i = 0
     var it = xs.asInstanceOf[Product].productIterator
@@ -180,7 +180,7 @@ object Tuple {
     arr
   }
 
-  def $consArray[H](x: H, elems: Array[Object]): Array[Object] = {
+  def cons$Array[H](x: H, elems: Array[Object]): Array[Object] = {
     val elems1 = new Array[Object](elems.length + 1)
     elems1(0) = x.asInstanceOf[Object]
     System.arraycopy(elems, 0, elems1, 1, elems.length)
@@ -217,7 +217,7 @@ object Tuple {
     }
 
   inline def stagedFromArray[T <: Tuple](xs: Array[Object]): T =
-    ~StagedTuple.fromArrayStaged[T]('(xs), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.fromArrayStaged[T]('{xs}, constValueOpt[BoundedSize[this.type]]) }
 
   def dynamicFromArray[T <: Tuple](xs: Array[Object]): T = xs.length match {
     case 0  => ().asInstanceOf[T]
@@ -248,7 +248,7 @@ object Tuple {
 
   def dynamicToArray(self: Tuple): Array[Object] = (self: Any) match {
     case self: Unit =>
-      $emptyArray
+      empty$Array
     case self: Tuple1[_] =>
       val t = self.asInstanceOf[Tuple1[Object]]
       Array(t._1)
@@ -283,7 +283,7 @@ object Tuple {
       case self: Tuple4[_, _, _, _] =>
         Tuple5(x, self._1, self._2, self._3, self._4).asInstanceOf[Result]
       case _ =>
-        dynamicFromArray[Result]($consArray(x, dynamicToArray(self)))
+        dynamicFromArray[Result](cons$Array(x, dynamicToArray(self)))
     }
   }
 
@@ -340,7 +340,7 @@ sealed trait NonEmptyTuple extends Tuple {
     }
 
   inline def stagedHead: Head[this.type] =
-    ~StagedTuple.headStaged[this.type]('(this), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.headStaged[this.type]('{this}, constValueOpt[BoundedSize[this.type]]) }
 
   inline def tail: Tail[this.type] =
     if (stageIt) stagedTail
@@ -369,7 +369,7 @@ sealed trait NonEmptyTuple extends Tuple {
     }
 
   inline def stagedTail: Tail[this.type] =
-    ~StagedTuple.tailStaged[this.type]('(this), constValueOpt[BoundedSize[this.type]])
+    ${ StagedTuple.tailStaged[this.type]('{this}, constValueOpt[BoundedSize[this.type]]) }
 
   inline def fallbackApply(n: Int) =
     inline constValueOpt[n.type] match {
@@ -429,9 +429,9 @@ sealed trait NonEmptyTuple extends Tuple {
     }
 
   inline def stagedApply(n: Int): Elem[this.type, n.type] =
-    ~StagedTuple.applyStaged[this.type, n.type](
-      '(this), constValueOpt[Size[this.type]],
-      '(n), constValueOpt[n.type])
+    ${ StagedTuple.applyStaged[this.type, n.type](
+       '{this}, constValueOpt[Size[this.type]],
+       '{n}, constValueOpt[n.type]) }
 }
 
 object NonEmptyTuple {

library/src-bootstrapped/scala/Tuple.scala

@@ -10,7 +10,7 @@ package object quoted {
     def toExprOfList(implicit ev: Type[T]): Expr[List[T]] = {
       def rec(list: List[Expr[T]]): Expr[List[T]] = list match {
         case x :: xs  => '{ (~x) :: (~rec(xs)) }
-        case Nil => '(Nil)
+        case Nil => '{Nil}
       }
       rec(list)
     }

library/src-bootstrapped/scala/quoted/package.scala

@@ -14,7 +14,7 @@ trait TreeUtils {
     val rhsExpr = rhs.seal[T]
     val expr = '{
       val x = ~rhsExpr
-      ~in(('(x)).unseal.asInstanceOf[Term.Ident]).seal[Any]
+      ${ in(('{x}).unseal.asInstanceOf[Term.Ident]).seal[Any] }
     }
     expr.unseal
   }

library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala

@@ -3,7 +3,7 @@ package scala.quoted
 import scala.runtime.quoted.Unpickler.liftedExpr
 
 /** A typeclass for types that can be turned to `quoted.Expr[T]`
- *  without going through an explicit `'(...)` operation.
+ *  without going through an explicit `'{...}` operation.
  */
 abstract class Liftable[T] {
   def toExpr(x: T): Expr[T]