Backport "Fix regression #23969: Add ensureApplied to the quotes reflect API" to 3.8.0

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -484,6 +484,9 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           argss.foldLeft(self: Term)(Apply(_, _))
         def appliedToNone: Apply =
           self.appliedToArgs(Nil)
+        def ensureApplied: Term =
+          def isParameterless(tpe: TypeRepr): Boolean = !tpe.isInstanceOf[MethodType]
+          if (isParameterless(self.tpe.widen)) self else self.appliedToNone
         def appliedToType(targ: TypeRepr): Term =
           self.appliedToTypes(targ :: Nil)
         def appliedToTypes(targs: List[TypeRepr]): Term =

library/src/scala/quoted/Quotes.scala

@@ -890,6 +890,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         /** The current tree applied to (): `tree()` */
         def appliedToNone: Apply
 
+        /** The current tree applied to `()` unless the tree's widened type is parameterless or expects type parameters */
+        def ensureApplied: Term
+
         /** The current tree applied to given type argument: `tree[targ]` */
         def appliedToType(targ: TypeRepr): Term
 

project/MiMaFilters.scala

@@ -140,6 +140,7 @@ object MiMaFilters {
           ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#ValDefModule.let"),
           ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#SymbolModule.newClass"),
           ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#SymbolModule.newModule"),
+          ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#TermMethods.ensureApplied"),
 
           // Changes to lazy vals (added static constructors)
           ProblemFilters.exclude[DirectMissingMethodProblem]("scala.Tuple.<clinit>"),

tests/neg-macros/i23008.check

@@ -3,13 +3,6 @@
   |                 ^^^^^^^^^^^^^^^^^^
   |                 Exception occurred while executing macro expansion.
   |                 java.lang.IllegalArgumentException: requirement failed: value of StringConstant cannot be `null`
-  |                 	at scala.Predef$.require(Predef.scala:394)
-  |                 	at scala.quoted.runtime.impl.QuotesImpl$reflect$StringConstant$.apply(QuotesImpl.scala:2542)
-  |                 	at scala.quoted.runtime.impl.QuotesImpl$reflect$StringConstant$.apply(QuotesImpl.scala:2541)
-  |                 	at scala.quoted.ToExpr$StringToExpr.apply(ToExpr.scala:82)
-  |                 	at scala.quoted.ToExpr$StringToExpr.apply(ToExpr.scala:80)
-  |                 	at scala.quoted.Expr$.apply(Expr.scala:72)
-  |                 	at Macros$.buildStringCode(Macro_1.scala:9)
   |
   |---------------------------------------------------------------------------------------------------------------------
   |Inline stack trace

tests/neg-macros/i23008/Macro_1.scala

@@ -6,6 +6,11 @@ object Macros {
   def buildStringCode(using Quotes): Expr[String] = {
     import quotes.reflect.*
     val str: String = null
-    Expr(str)
+    try
+      Expr(str)
+    catch
+      case error: java.lang.IllegalArgumentException =>
+        error.setStackTrace(Array[StackTraceElement]())
+        throw error
   }
 }

tests/pos-macros/i23969/Macro.scala

@@ -0,0 +1,41 @@
+
+import scala.quoted._
+
+object TestMethods:
+  def a1 = ()
+  def a2() = ()
+  def a3[T] = ()
+  def a4[T]() = ()
+
+transparent inline def runMacro() = ${runMacroImpl}
+def runMacroImpl(using Quotes): Expr[Any] =
+  import quotes.reflect._
+
+  // ensureApplied test
+  Select.unique('{TestMethods}.asTerm, "a1").ensureApplied match
+    case Select(_, _) =>
+    case _ => assert(false)
+  Select.unique('{TestMethods}.asTerm, "a2").ensureApplied match
+    case Apply(_, _) =>
+    case _ => assert(false)
+  Select.unique('{TestMethods}.asTerm, "a3").ensureApplied match
+    case Select(_, _) =>
+    case other => assert(false)
+  Select.unique('{TestMethods}.asTerm, "a4").ensureApplied match
+    case Select(_, _) =>
+    case other => assert(false)
+
+  TypeApply(Select.unique('{TestMethods}.asTerm, "a3"), List(TypeTree.of[Nothing])).ensureApplied match
+    case TypeApply(_, _) =>
+    case other => assert(false)
+  TypeApply(Select.unique('{TestMethods}.asTerm, "a4"), List(TypeTree.of[Nothing])).ensureApplied match
+    case Apply(_, _) =>
+    case other => assert(false)
+
+  // regression test
+  val Inlined(_, _, generated) = '{BigDecimal(0).toString()}.asTerm : @unchecked
+  val Inlined(_, _, bigDecimal) = '{BigDecimal(0)}.asTerm : @unchecked
+  val custom = Select.unique(bigDecimal, "toString").ensureApplied
+  // ensure both have the same shape
+  assert(custom.toString == generated.toString)
+  custom.asExpr

tests/pos-macros/i23969/Main.scala

@@ -0,0 +1 @@
+@main def Test() = runMacro()