Implement compiletime.code with a macro

Now, the implemetation is simpler with macros.

Author: nicolasstucki

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

@@ -705,41 +705,6 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
       case _ =>
     }
 
-    def issueCode()(using Context): Literal = {
-      def decompose(arg: Tree): String = arg match {
-        case Typed(arg, _) => decompose(arg)
-        case SeqLiteral(elems, _) => elems.map(decompose).mkString(", ")
-        case Block(Nil, expr) => decompose(expr)
-        case Inlined(_, Nil, expr) => decompose(expr)
-        case arg =>
-          arg.tpe.widenTermRefExpr match {
-            case ConstantType(Constant(c)) => c.toString
-            case _ => arg.show
-          }
-      }
-
-      def malformedString(): String = {
-        ctx.error("Malformed part `code` string interpolator", call.sourcePos)
-        ""
-      }
-
-      callValueArgss match {
-        case List(List(Apply(_,List(Typed(SeqLiteral(Literal(headConst) :: parts,_),_)))), List(Typed(SeqLiteral(interpolatedParts,_),_)))
-            if parts.size == interpolatedParts.size =>
-          val constantParts = parts.map {
-            case Literal(const) => const.stringValue
-            case _ => malformedString()
-          }
-          val decomposedInterpolations = interpolatedParts.map(decompose)
-          val constantString = decomposedInterpolations.zip(constantParts)
-              .foldLeft(headConst.stringValue) { case (acc, (p1, p2)) => acc + p1 + p2 }
-
-          Literal(Constant(constantString)).withSpan(call.span)
-        case _ =>
-          Literal(Constant(malformedString()))
-      }
-    }
-
     trace(i"inlining $call", inlining, show = true) {
 
       // The normalized bindings collected in `bindingsBuf`
@@ -763,12 +728,9 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
 
       if (inlinedMethod == defn.Compiletime_error) issueError()
 
-      if (inlinedMethod == defn.Compiletime_code)
-        issueCode()(using ctx.fresh.setSetting(ctx.settings.color, "never"))
-      else
-        // Take care that only argument bindings go into `bindings`, since positions are
-        // different for bindings from arguments and bindings from body.
-        tpd.Inlined(call, finalBindings, finalExpansion)
+      // Take care that only argument bindings go into `bindings`, since positions are
+      // different for bindings from arguments and bindings from body.
+      tpd.Inlined(call, finalBindings, finalExpansion)
     }
   }
 

library/src/scala/compiletime/package.scala

@@ -1,5 +1,7 @@
 package scala
 
+import scala.quoted._
+
 package object compiletime {
 
   erased def erasedValue[T]: T = ???
@@ -17,7 +19,7 @@ package object compiletime {
    */
   inline def error(inline msg: String): Nothing = ???
 
-  /** Returns the string representation of interpolated values:
+  /** Returns the string representation of interpolated elaborated code:
    *
    *  ```scala
    *  inline def logged(p1: => Any) = {
@@ -27,13 +29,19 @@ package object compiletime {
    *  }
    *  logged(identity("foo"))
    *  // above is equivalent to:
-   *  // ("code: identity("foo")", identity("foo"))
+   *  // ("code: scala.Predef.identity("foo")", identity("foo"))
    *  ```
    *
    * @note only by-name arguments will be displayed as "code".
    *       Other values may display unintutively.
    */
-  inline def (self: => StringContext) code (args: => Any*): String = ???
+  transparent inline def (inline self: StringContext) code (inline args: Any*): String = ${ codeExpr('self, 'args) }
+  private def codeExpr(using qctx: QuoteContext)(sc: Expr[StringContext], args: Expr[Seq[Any]]): Expr[String] =
+    (sc, args) match
+      case ('{ StringContext(${Varargs(Consts(parts))}: _*) }, Varargs(args2)) =>
+        Expr(StringContext(parts: _*).s(args2.map(_.show): _*))
+      case _ =>
+        qctx.throwError("compiletime.code must be used as a string interpolator code\"...\"")
 
   inline def constValueOpt[T]: Option[T] = ???
 

tests/neg/i6622f.check

@@ -1,4 +1,4 @@
 -- Error: tests/neg/i6622f.scala:6:8 -----------------------------------------------------------------------------------
 6 |    fail(println("foo")) // error
   |    ^^^^^^^^^^^^^^^^^^^^
-  |    failed: println("foo") ...
+  |    failed: scala.Predef.println("foo") ...

tests/run/i6622.scala

@@ -3,10 +3,10 @@ import scala.compiletime._
 object Test {
 
   def main(args: Array[String]): Unit = {
-    assert(code"abc ${println(34)} ..." == "abc println(34) ...")
-    assert(code"abc ${println(34)}" == "abc println(34)")
-    assert(code"${println(34)} ..." == "println(34) ...")
-    assert(code"${println(34)}" == "println(34)")
+    assert(code"abc ${println(34)} ..." == "abc scala.Predef.println(34) ...")
+    assert(code"abc ${println(34)}" == "abc scala.Predef.println(34)")
+    assert(code"${println(34)} ..." == "scala.Predef.println(34) ...")
+    assert(code"${println(34)}" == "scala.Predef.println(34)")
     assert(code"..." == "...")
     assert(testConstant(code"") == "")
   }