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
+
 }