wip

Author: nicolasstucki

compiler/src/dotty/tools/dotc/transform/Splicer.scala

@@ -159,6 +159,11 @@ object Splicer {
         case tree: Ident if tree.symbol.is(Inline) || summon[Env].contains(tree.symbol) =>
           // OK
 
+        // TODO remove case
+        case Apply(Select(TypeApply(unsafeExpr, _), nme.apply), List(expr))
+            if unsafeExpr.symbol.showFullName ==  "scala.quoted.QuoteScope.unsafeExpr" =>
+          checkIfValidArgument(expr)
+
         case _ =>
           val extra = if tree.span.isZeroExtent then ": " + tree.show else ""
           ctx.error(
@@ -242,6 +247,11 @@ object Splicer {
           if unsafe.symbol == defn.QuotedExprModule_unsafeExpr || unsafe.symbol == defn.QuotedTypeModule_unsafeType =>
         interpretTree(expr)
 
+      // TODO remove case
+      case Apply(Select(TypeApply(unsafeExpr, _), nme.apply), List(expr))
+          if unsafeExpr.symbol.showFullName ==  "scala.quoted.QuoteScope.unsafeExpr" =>
+        interpretTree(expr)
+
       case TypeApply(aio @ Select(expr, _), _) if aio.symbol == defn.Any_typeCast =>
         interpretTree(expr)
 

library/src-bootstrapped/dotty/internal/CompileTimeMacros.scala

@@ -3,9 +3,9 @@ package dotty.internal
 import scala.quoted._
 
 object CompileTimeMacros:
-  def codeExpr(using qctx: QuoteContext)(sc: Expr[StringContext], args: Expr[Seq[Any]]): Expr[String] =
+  def codeExpr(using s: QuoteScope)(sc: s.Expr[StringContext], args: s.Expr[Seq[Any]]): s.Expr[String] =
     (sc, args) match
-      case (Expr.StringContext(Consts(parts)), Varargs(args2)) =>
+      case (s.Expr.StringContext(Consts(parts)), s.Varargs(args2)) =>
         Expr(StringContext(parts: _*).s(args2.map(_.show): _*))
       case _ =>
         Reporting.throwError("compiletime.code must be used as a string interpolator `code\"...\"`")

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

@@ -187,7 +187,7 @@ object Expr {
   /** Given a tuple of the form `(Expr[A1], ..., Expr[An])`, outputs a tuple `Expr[(A1, ..., An)]`. */
   def ofTuple[T <: Tuple](tup: T)(using s: QuoteScope)(using s.Type[T], Tuple.IsMappedBy[s.Expr][T]): s.Expr[Tuple.InverseMap[T, s.Expr]] = {
     val elems: Seq[s.Expr[Any]] = tup.asInstanceOf[Product].productIterator.toSeq.asInstanceOf[Seq[s.Expr[Any]]]
-    ofTupleFromSeq(elems).asInstanceOf[s.Expr[Tuple.InverseMap[T, s.Expr]]]
+    ofTupleFromSeq(elems.asInstanceOf[Seq[Expr[Any]]]).asInstanceOf[s.Expr[Tuple.InverseMap[T, s.Expr]]] // TODO remove asInstanceOf[Seq[Expr[Any]]]
   }
 
   /** Find an implicit of type `T` in the current scope given by `qctx`.

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

@@ -15,14 +15,14 @@ object Lambda {
    *       body('{3}) // returns '{ println(3) }
    *   ```
    */
-  def unapply[F, Args <: Tuple, Res, G](using s: QuoteScope)(expr: s.Expr[F])(using tf: TupledFunction[F, Args => Res], tg: TupledFunction[G, Tuple.Map[Args, s.Expr] => Expr[Res]], functionType: Type[F]): Option[/*QuoteContext ?=>*/ G] = {
+  def unapply[F, Args <: Tuple, Res, G](using s: QuoteScope)(expr: s.Expr[F])(using tf: TupledFunction[F, Args => Res], tg: TupledFunction[G, Tuple.Map[Args, s.Expr] => s.Expr[Res]], functionType: Type[F]): Option[/*QuoteContext ?=>*/ G] = {
     import qctx.tasty._
     val argTypes = functionType.unseal.tpe match
       case AppliedType(_, functionArguments) => functionArguments.init.asInstanceOf[List[Type]]
     qctx.tasty.internal.lambdaExtractor(expr.unseal, argTypes).map { fn =>
       def f(args: Tuple.Map[Args, s.Expr]): s.Expr[Res] =
         fn(args.toArray.toList.map(_.asInstanceOf[s.Expr[Any]].unseal)).seal.asInstanceOf[s.Expr[Res]]
-      tg.untupled(f)
+      tg.untupled(f) // TODO remove asInstanceOf
     }
 
   }

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

@@ -110,12 +110,12 @@ object Liftable {
 
   given [T: Type: Liftable] as Liftable[Seq[T]] = new Liftable[Seq[T]] {
     def toExpr(xs: Seq[T]): (s: QuoteScope) ?=> s.Expr[Seq[T]] =
-      Expr.ofSeq(xs.map(summon[Liftable[T]].toExpr))
+      Expr.ofSeq[T](xs.map(x => summon[Liftable[T]].toExpr(x).asInstanceOf[Expr[T]]))
   }
 
   given [T: Type: Liftable] as Liftable[List[T]] = new Liftable[List[T]] {
     def toExpr(xs: List[T]): (s: QuoteScope) ?=> s.Expr[List[T]] =
-      Expr.ofList(xs.map(summon[Liftable[T]].toExpr))
+      Expr.ofList(xs.map(x => summon[Liftable[T]].toExpr(x).asInstanceOf[Expr[T]]))
   }
 
   given [T: Type: Liftable] as Liftable[Set[T]] = new Liftable[Set[T]] {

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

@@ -13,13 +13,17 @@ import scala.quoted.show.SyntaxHighlight
 trait QuoteScope { self =>
 
   /** Quoted expression of type `T` */
-  type Expr[+T] <: scala.quoted.Expr[T] // TODO replace `<: scala.quoted.Expr[T]` with `<: tasty.Term`
+  type Expr[+T] // TODO replace `<: scala.quoted.Expr[T]` with `<: tasty.Term`
 
-  object Expr {
+  /** Show a source code like representation of this expression without syntax highlight */
+  def [T](expr: Expr[T]).show(using QuoteScope): String =
+    expr.unseal.showWith(SyntaxHighlight.plain)
+
+  /** View this expression `Expr[T]` as a `Term` */
+  def [T](expr: Expr[T]).unseal: self.tasty.Term =
+    self.tasty.internal.QuotedExpr_unseal(expr.asInstanceOf[scala.quoted.Expr[T]])(using self.tasty.rootContext)
 
-    // /** Show a source code like representation of this expression without syntax highlight */
-    // def [T](expr: Expr[T]).show(using QuoteScope): String =
-    //   expr.unseal.showWith(SyntaxHighlight.plain)
+  object Expr {
 
     // /** Show a source code like representation of this expression */
     // def show(syntaxHighlight: SyntaxHighlight)(using qctx: QuoteContext): String =
@@ -56,14 +60,29 @@ trait QuoteScope { self =>
     // def cast[U](using tp: scala.quoted.Type[U])(using qctx: QuoteContext): scala.quoted.Expr[U] =
     //   qctx.tasty.internal.QuotedExpr_cast[U](expr)(using tp, qctx.tasty.rootContext)
 
-    /** View this expression `Expr[T]` as a `Term` */
-    def [T](expr: Expr[T]).unseal: self.tasty.Term =
-      self.tasty.internal.QuotedExpr_unseal(expr.asInstanceOf[scala.quoted.Expr[T]])(using self.tasty.rootContext)
+    object StringContext {
+      /** Matches a `StringContext(part0, part1, ...)` and extracts the parts of a call to if the
+       *  parts are passed explicitly. Returns the equvalent to `Seq('{part0}, '{part1}, ...)`.
+       */
+      def unapply(sc: Expr[StringContext]): Option[Seq[Expr[String]]] =
+        val qctx = self.asInstanceOf[QuoteContext & self.type] // FIXME remove
+        given qctx.type = qctx
+        sc.asInstanceOf[scala.quoted.Expr[StringContext]] match
+          case '{ scala.StringContext(${scala.quoted.Varargs(parts)}: _*) } => Some(parts.asInstanceOf[Seq[Expr[String]]])
+          case '{ new scala.StringContext(${scala.quoted.Varargs(parts)}: _*) } => Some(parts.asInstanceOf[Seq[Expr[String]]])
+          case _ => None
+    }
+
+
   }
 
   /** Quoted type (or kind) `T` */
   type Type[T <: AnyKind] <: scala.quoted.Type[T] // TODO replace `<: scala.quoted.Type[T]` with `<: tasty.Type`
 
+  /** View this expression `Type[T]` as a `tasty.TypeTree` */
+  def [T <: AnyKind](tpe: Type[T]).unseal: self.tasty.TypeTree =
+    self.tasty.internal.QuotedType_unseal(tpe.asInstanceOf[scala.quoted.Type[T]])(using self.tasty.rootContext)
+
   object Type {
     // /** Show a source code like representation of this type without syntax highlight */
     // def show(using qctx: QuoteContext): String =
@@ -73,9 +92,6 @@ trait QuoteScope { self =>
     // def show(syntaxHighlight: SyntaxHighlight)(using qctx: QuoteContext): String =
     //   this.unseal.showWith(syntaxHighlight)
 
-    /** View this expression `Type[T]` as a `tasty.TypeTree` */
-    def [T <: AnyKind](tpe: Type[T]).unseal: self.tasty.TypeTree =
-      self.tasty.internal.QuotedType_unseal(tpe.asInstanceOf[scala.quoted.Type[T]])(using self.tasty.rootContext)
   }
 
   /** Low-level Typed AST API `tasty` meta-programming API.
@@ -102,4 +118,51 @@ trait QuoteScope { self =>
     val tasty: self.tasty.type
   }
 
+  /** Literal sequence of expressions */
+  object Varargs {
+
+    /** Lifts this sequence of expressions into an expression of a sequence
+    *
+    *  Transforms a sequence of expression
+    *    `Seq(e1, e2, ...)` where `ei: Expr[T]`
+    *  to an expression equivalent to
+    *    `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]`
+    *
+    *  Usage:
+    *  ```scala
+    *  '{ List(${Varargs(List(1, 2, 3))}: _*) } // equvalent to '{ List(1, 2, 3) }
+    *  ```
+    */
+    def apply[T](xs: Seq[Expr[T]])(using tp: Type[T]): Expr[Seq[T]] = {
+      import tasty._
+      Repeated(xs.map[Term](_.unseal).toList, self.unseal(tp)).seal.asInstanceOf[Expr[Seq[T]]] // cast OK
+    }
+
+    /** Matches a literal sequence of expressions and return a sequence of expressions.
+    *
+    *  Usage:
+    *  ```scala
+    *  inline def sum(args: Int*): Int = ${ sumExpr('args) }
+    *  def sumExpr(argsExpr: Expr[Seq[Int]])(using QuoteContext): Expr[Int] = argsExpr match
+    *    case Varargs(argVarargs) =>
+    *      // argVarargs: Seq[Expr[Int]]
+    *      ...
+    *  }
+    *  ```
+    */
+    def unapply[T](expr: Expr[Seq[T]]): Option[Seq[Expr[T]]] = {
+      import tasty._
+      def rec(tree: Term): Option[Seq[Expr[T]]] = tree match {
+        case Typed(Repeated(elems, _), _) => Some(elems.map(x => x.seal.asInstanceOf[Expr[T]])) // ccast OK
+        case Block(Nil, e) => rec(e)
+        case Inlined(_, Nil, e) => rec(e)
+        case _  => None
+      }
+      rec(expr.unseal)
+    }
+
+  }
+
+  given unsafeExpr[T] as Conversion[Expr[T], scala.quoted.Expr[T]] = _.asInstanceOf
+
 }

tests/neg/toexproftuple.scala renamed to tests/disabled/neg-macros/toexproftuple.scala

@@ -26,7 +26,7 @@ object Lifters {
 
   private def initArray[T : Liftable : Type](arr: Array[T], array: Expr[Array[T]])(using QuoteContext): Expr[Array[T]] = {
     UnrolledExpr.block(
-      arr.zipWithIndex.map {
+      arr.zipWithIndex.map[Expr[Unit]] {
         case (x, i) => '{ $array(${i}) = ${x} }
       }.toList,
       array)

tests/run-staging/i6281.scala renamed to tests/disabled/run-staging/i6281.scala

@@ -20,7 +20,7 @@ object Vmults {
   }
 
   def vmultCA(using QuoteContext): Expr[(Array[Complex[Int]], Array[Complex[Int]], Array[Complex[Int]]) => Unit] = '{
-    (vout, v1, v2) => {
+    (vout: Array[Complex[Int]], v1: Array[Complex[Int]], v2: Array[Complex[Int]]) => {
       val n = vout.length
       ${
         val vout_ = OVec[Expr[Int], Complex[Expr[Int]], Expr[Unit]]('n, (i, v) => '{vout($i) = ${Complex.of_expr_complex(v)}})

tests/run-staging/shonan-hmm/Blas.scala renamed to tests/disabled/run-staging/shonan-hmm/Blas.scala

@@ -0,0 +1,6 @@
+package macros
+import scala.quoted._
+import scala.util.control.NonLocalReturns._
+
+def oops(using s: QuoteScope): s.Expr[Int] =
+  returning('{ { (x: Int) => ${ throwReturn('x) }} apply 0 }) // error

tests/run-staging/shonan-hmm/Complex.scala renamed to tests/disabled/run-staging/shonan-hmm/Complex.scala

@@ -2,5 +2,5 @@ import scala.quoted._
 
 object Foo {
   inline def foo(): Int = ${$x} // error
-  def x(using QuoteContext): Expr[Expr[Int]] = '{ '{1} }
+  def x(using QuoteContext): Expr[Expr[Int]] = '{ '{1} } // error
 }

tests/run-staging/shonan-hmm/Lifters.scala renamed to tests/disabled/run-staging/shonan-hmm/Lifters.scala

@@ -2,6 +2,6 @@ import scala.quoted._
 
 inline def mcr: Any = ${mcrImpl}
 def mcrImpl(using ctx: QuoteContext): Expr[Any] = {
-  val tpl: Expr[1] = '{1}
+  val tpl: Expr[1] = '{1}.asInstanceOf[Expr[1]] // FIXME: remove asInstanceOf
   '{()}
 }

tests/run-staging/shonan-hmm/MVmult.scala renamed to tests/disabled/run-staging/shonan-hmm/MVmult.scala

@@ -0,0 +1,6 @@
+
+import scala.quoted._
+
+def f(using s: QuoteScope) = {
+  val x: s.Expr[Double] = '{5: Double} // FIXME remove ascription
+}

tests/run-staging/shonan-hmm/PV.scala renamed to tests/disabled/run-staging/shonan-hmm/PV.scala

@@ -6,7 +6,7 @@ class Foo {
    ${ this.a }
  }
 
-  def d(using QuoteContext): Expr[QuoteContext ?=> Expr[Int]] = '{ '{1} }
+  def d(using QuoteContext): Expr[QuoteContext ?=> Expr[Int]] = '{ (using q: QuoteContext) => '{1} } // FIXME
 
  def foo[T](x: T): T = x
 

tests/run-staging/shonan-hmm/Ring.scala renamed to tests/disabled/run-staging/shonan-hmm/Ring.scala

@@ -17,6 +17,6 @@ object Macros {
             s"$name : $returnType"
       }.sorted
 
-    methods.foldLeft('{}) { (res, m) => '{ $res; println(${m}) } }
+    methods.foldLeft[Expr[Unit]]('{}) { (res, m) => '{ $res; println(${m}) } }
   }
 }

tests/run-staging/shonan-hmm/Test.scala renamed to tests/disabled/run-staging/shonan-hmm/Test.scala

@@ -6,7 +6,7 @@ inline def (sc: StringContext) showMe(inline args: Any*): String = ${ showMeExpr
 private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using qctx: QuoteContext): Expr[String] = {
   argsExpr match {
     case Varargs(argExprs) =>
-      val argShowedExprs = argExprs.map {
+      val argShowedExprs = argExprs.map[Expr[Any]] {
         case '{ $arg: $tp } =>
           val showTp = '[Show[$tp]]
           Expr.summon[Show[$tp]] match {

tests/run-staging/shonan-hmm/UnrolledExpr.scala renamed to tests/disabled/run-staging/shonan-hmm/UnrolledExpr.scala

@@ -3,7 +3,7 @@ import scala.quoted.staging._
 
 object Test {
   given Toolbox = Toolbox.make(getClass.getClassLoader)
-  def eval1(ff: Expr[Int => Int])(using QuoteContext): Expr[Int => Int] = '{identity}
+  def eval1(ff: Expr[Int => Int])(using QuoteContext): Expr[Int => Int] = '{identity[Int]}
 
   def peval1()(using QuoteContext): Expr[Unit] = '{
     lazy val f: Int => Int = ${eval1('{(y: Int) => f(y)})}

tests/run-staging/shonan-hmm/Vec.scala renamed to tests/disabled/run-staging/shonan-hmm/Vec.scala

@@ -12,9 +12,9 @@ object Test {
     println(ack3(4))
   }
 
-  def ackermann(m: Int)(using QuoteContext): Expr[Int => Int] = {
-    if (m == 0) '{ n => n + 1 }
-    else '{ n =>
+  def ackermann(m: Int)(using s: QuoteScope): s.Expr[Int => Int] = {
+    if (m == 0) '{ (n: Int) => n + 1 } // FIXME infer parameter type
+    else '{ (n: Int) =>
       def `ackermann(m-1)`(n: Int): Int = ${Expr.betaReduce(ackermann(m - 1))('n)} // Expr[Int => Int] applied to Expr[Int]
       def `ackermann(m)`(n: Int): Int =
         if (n == 0) `ackermann(m-1)`(1) else `ackermann(m-1)`(`ackermann(m)`(n - 1))

tests/run-staging/shonan-hmm/VecOp.scala renamed to tests/disabled/run-staging/shonan-hmm/VecOp.scala

@@ -12,8 +12,8 @@ object Test {
     println(f(43))
   }
 
-  def f1(using QuoteContext): Expr[Int => Int] = '{ n => ${Expr.betaReduce(f2)('n)} }
-  def f2(using QuoteContext): Expr[Int => Int] = '{ n => ${Expr.betaReduce(f3)('n)} }
-  def f3(using QuoteContext): Expr[Int => Int] = '{ n => ${Expr.betaReduce(f4)('n)} }
-  def f4(using QuoteContext): Expr[Int => Int] = '{ n => n }
+  def f1(using QuoteContext): Expr[Int => Int] = '{ (n: Int) => ${Expr.betaReduce(f2)('n)} } // FIXME infer parameter type
+  def f2(using QuoteContext): Expr[Int => Int] = '{ (n: Int) => ${Expr.betaReduce(f3)('n)} }
+  def f3(using QuoteContext): Expr[Int => Int] = '{ (n: Int) => ${Expr.betaReduce(f4)('n)} }
+  def f4(using QuoteContext): Expr[Int => Int] = '{ (n: Int) => n }
 }

tests/run-staging/shonan-hmm/VecROp.scala renamed to tests/disabled/run-staging/shonan-hmm/VecROp.scala

@@ -11,10 +11,10 @@ object Test {
       else if (n % 2 == 0) '{ { val y = $x * $x; ${powerCode(n / 2, 'y)} } }
       else '{ $x * ${powerCode(n - 1, x)} }
 
-    println(powerCode(0, '{5}).show)
-    println(powerCode(1, '{5}).show)
-    println(powerCode(2, '{5}).show)
-    println(powerCode(3, '{5}).show)
-    println(powerCode(22, '{5}).show)
+    println(powerCode(0, '{5.0}).show)
+    println(powerCode(1, '{5.0}).show)
+    println(powerCode(2, '{5.0}).show)
+    println(powerCode(3, '{5.0}).show)
+    println(powerCode(22, '{5.0}).show)
   }
 }

tests/run-staging/shonan-hmm/Vmults.scala renamed to tests/disabled/run-staging/shonan-hmm/Vmults.scala

@@ -18,7 +18,7 @@ object Test {
     println(code1Tpe2.show)
     println()
 
-    def code2(using QuoteContext) = '{ (arr: Array[Int]) => ${ foreach1('arr, '{i => System.out.println(i)}) } }
+    def code2(using QuoteContext) = '{ (arr: Array[Int]) => ${ foreach1('arr, '{(i: Int) => System.out.println(i)}) } }
     println(code2.show)
     println()
 
@@ -37,7 +37,7 @@ object Test {
 
     def printAll(arr: Array[Int]) = '{
       val arr1 = ${ arr }
-      ${ foreach1('arr1, '{x => println(x)}) }
+      ${ foreach1('arr1, '{(x: Int) => println(x)}) }
     }
 
     println(printAll(Array(1, 3, 4, 5)).show)

tests/neg-macros/i7142.scala

@@ -10,7 +10,7 @@ object Test {
   }
 
   def powerCode(n: Long)(using QuoteContext): Expr[Double => Double] =
-    '{ x1 => ${powerCode(n, 2, 'x1)} }
+    '{ (x1: Double) => ${powerCode(n, 2, 'x1)} }
 
   def powerCode(n: Long, idx: Int, x: Expr[Double])(using QuoteContext): Expr[Double] =
     if (n == 0) '{1.0}