Fix #3912: Account for units and blocks in inline and macros

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

@@ -321,16 +321,22 @@ class ReifyQuotes extends MacroTransformWithImplicits {
             val last = enteredSyms
             stats.foreach(markDef)
             mapOverTree(last)
-          case Inlined(call, bindings, expansion @ Select(body, name)) if expansion.symbol.isSplice =>
+
+          case Inlined(call, bindings, InlineSplice(expansion @ Select(body, name))) =>
             // To maintain phase consistency, we move the binding of the this parameter into the spliced code
             val (splicedBindings, stagedBindings) = bindings.partition {
               case vdef: ValDef => vdef.symbol.is(Synthetic) // Assume that only _this bindings are tagged with Synthetic
               case _ => false
             }
+
             val tree1 =
               if (level == 0) cpy.Inlined(tree)(call, stagedBindings, Splicer.splice(seq(splicedBindings, body)))
               else seq(stagedBindings, cpy.Select(expansion)(cpy.Inlined(tree)(call, splicedBindings, body), name))
-            transform(tree1)
+            val tree2 = transform(tree1)
+
+            // due to value-discarding which converts an { e } into { e; () })
+            if (tree.tpe =:= defn.UnitType) Block(tree2 :: Nil, Literal(Constant(())))
+            else tree2
           case _: Import =>
             tree
           case tree: DefDef if tree.symbol.is(Macro) && level == 0 =>
@@ -343,5 +349,20 @@ class ReifyQuotes extends MacroTransformWithImplicits {
             checkLevel(mapOverTree(enteredSyms))
         }
       }
+
+    /** InlineSplice is used to detect cases where the expansion
+     *  consists of a (possibly multiple & nested) block or a sole expression.
+     */
+    object InlineSplice {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Select] = {
+        tree match {
+          case expansion: Select if expansion.symbol.isSplice =>
+            Some(expansion)
+          case Block(List(stat), Literal(Constant(()))) => unapply(stat)
+          case Block(Nil, expr) => unapply(expr)
+          case _ => None
+        }
+      }
+    }
   }
 }

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

@@ -6,13 +6,13 @@ import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.quoted._
 import dotty.tools.dotc.interpreter._
 
-/** Utility class to slice quoted expressions */
+/** Utility class to splice quoted expressions */
 object Splicer {
   import tpd._
 
   /** Splice the Tree for a Quoted expression. `~'(xyz)` becomes `xyz`
    *  and for `~xyz` the tree of `xyz` is interpreted for which the
-   *  resulting expression is return as a `Tree`
+   *  resulting expression is returned as a `Tree`
    */
   def splice(tree: Tree)(implicit ctx: Context): Tree = tree match {
     case Quoted(quotedTree) => quotedTree

tests/pos/i3912-1/i3912_1.scala

@@ -0,0 +1,7 @@
+import scala.quoted._
+
+object Macros {
+  inline def foo(): Int = { ~impl() }
+
+  def impl(): Expr[Int] = '(1)
+}

tests/pos/i3912-1/i3912_2.scala

@@ -0,0 +1,7 @@
+import scala.quoted._
+import Macros._
+
+class Test {
+  val a: Unit = foo()
+
+}

tests/pos/i3912-2/i3912_1.scala

@@ -0,0 +1,7 @@
+import scala.quoted._
+
+object Macros {
+  inline def foo2(): Unit = ~impl()
+
+  def impl(): Expr[Int] = '(1)
+}

tests/pos/i3912-2/i3912_2.scala

@@ -0,0 +1,6 @@
+import scala.quoted._
+import Macros._
+
+class Test {
+  val a2: Unit = foo2()
+}

tests/pos/i3912-3/i3912_1.scala

@@ -0,0 +1,11 @@
+import scala.quoted._
+
+object Macros {
+  inline def foo3(): Int = {
+    {
+      ~impl()
+    }
+  }
+
+  def impl(): Expr[Int] = '(1)
+}

tests/pos/i3912-3/i3912_2.scala

@@ -0,0 +1,6 @@
+import scala.quoted._
+import Macros._
+
+class Test {
+  val a3: Unit = foo3()
+}