clear up how report is imported

Author: bishabosha

_overviews/scala3-macros/tutorial/macros.md

@@ -14,13 +14,16 @@ Macros enable us to do exactly this: treat **programs as data** and manipulate t
 
 ## Macros Treat Programs as Values
 With a macro, we can treat programs as values, which allows us to analyze and generate them at compile time.
+
 A Scala expression with type `T` is represented by an instance of the type `scala.quoted.Expr[T]`.
 
 We will dig into the details of the type `Expr[T]`, as well as the different ways of analyzing and constructing instances, when talking about [Quoted Code][quotes] and [Reflection][tasty].
 For now, it suffices to know that macros are metaprograms that manipulate expressions of type `Expr[T]`.
 
-The following macro implementation simply prints the expression of the provided argument:
+The following macro implementation prints the expression of the provided argument:
 ```scala
+import scala.quoted.* // imports Quotes, Expr
+
 def inspectCode(x: Expr[Any])(using Quotes): Expr[Any] =
   println(x.show)
   x
@@ -138,12 +141,25 @@ This can only succeed, if the expression directly contains the code of a value,
 Instead of `valueOrAbort`, we could also use the `value` operation, which will return an `Option`.
 This way we can report the error with a custom error message.
 
+#### Reporting Custom Error Messages
+
+The contextual `Quotes` parameter provides a `report` object that we can use to report a custom error message.
+Within a macro implementation method, you can access the contextual `Quotes` parameter with the `quotes` method
+(imported with `import scala.quoted.*`), then import the `report` object by `import quotes.reflect.report`.
+
+#### Providing the Custom Error
+
+We will provide the custom error message by calling `errorAndAbort` on the `report` object as follows:
 ```scala
-  ...
-  import quotes.reflect.*
+def powerCode(
+  x: Expr[Double],
+  n: Expr[Int]
+)(using Quotes): Expr[Double] =
+  import quotes.reflect.report
   (x.value, n.value) match
     case (Some(base), Some(exponent)) =>
-      pow(base, exponent)
+      val value: Double = pow(base, exponent)
+      Expr(value)
     case (Some(_), _) =>
       report.errorAndAbort("Expected a known value for the exponent, but was " + n.show, n)
     case _ =>
@@ -154,30 +170,32 @@ Alternatively, we can also use the `Expr.unapply` extractor
 
 ```scala
   ...
-  import quotes.reflect.*
   (x, n) match
     case (Expr(base), Expr(exponent)) =>
-      pow(base, exponent)
+      val value: Double = pow(base, exponent)
+      Expr(value)
     case (Expr(_), _) => ...
     case _ => ...
 ```
-The operations `value`, `valueOrError`, and `Expr.unapply` will work for all _primitive types_, _tuples_ of any arity, `Option`, `Seq`, `Set`, `Map`, `Either` and `StringContext`.
+The operations `value`, `valueOrAbort`, and `Expr.unapply` will work for all _primitive types_, _tuples_ of any arity, `Option`, `Seq`, `Set`, `Map`, `Either` and `StringContext`.
 Other types can also work if an `FromExpr` is implemented for it, we will [see this later][quotes].
 
 
 ### Showing Expressions
 
 In the implementation of `inspectCode`, we have already seen how to convert expressions to the string representation of their _source code_ using the `.show` method.
 This can be useful to perform debugging on macro implementations:
+
+<!-- The below code example does not use multi-line string because it causes syntax highlighting to break -->
 ```scala
 def debugPowerCode(
   x: Expr[Double],
   n: Expr[Int]
 )(using Quotes): Expr[Double] =
   println(
-    s"""powerCode
-       |  x := ${x.show}
-       |  n := ${n.show}""".stripMargin)
+    s"powerCode \n" +
+    s"  x := ${x.show}\n" +
+    s"  n := ${n.show}")
   val code = powerCode(x, n)
   println(s"  code := ${code.show}")
   code
@@ -190,23 +208,24 @@ Varargs in Scala are represented with `Seq`, hence when we write a macro with a
 It is possible to recover each individual argument (of type `Expr[T]`) using the `scala.quoted.Varargs` extractor.
 
 ```scala
-import scala.quoted.Varargs
+import scala.quoted.{Varargs, *}
 
 inline def sumNow(inline nums: Int*): Int =
   ${ sumCode('nums)  }
 
 def sumCode(nums: Expr[Seq[Int]])(using Quotes): Expr[Int] =
+  import quotes.reflect.report
   nums match
     case  Varargs(numberExprs) => // numberExprs: Seq[Expr[Int]]
       val numbers: Seq[Int] = numberExprs.map(_.valueOrAbort)
       Expr(numbers.sum)
-    case _ => report.error(
-      "Expected explicit argument" +
-      "Notation `args: _*` is not supported.", numbersExpr)
+    case _ => report.errorAndAbort(
+      "Expected explicit varargs sequence. " +
+      "Notation `args*` is not supported.", nums)
 ```
 
 The extractor will match a call to `sumNow(1, 2, 3)` and extract a `Seq[Expr[Int]]` containing the code of each parameter.
-But, if we try to match the argument of the call `sumNow(nums: _*)`, the extractor will not match.
+But, if we try to match the argument of the call `sumNow(nums*)`, the extractor will not match.
 
 `Varargs` can also be used as a constructor. `Varargs(Expr(1), Expr(2), Expr(3))` will return an `Expr[Seq[Int]]`.
 We will see how this can be useful later.