remove usingquotes arg, fix unnecessary changes

Author: rochala

library/src/scala/quoted/Quotes.scala

@@ -2533,11 +2533,17 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         /** Convert this `TypeRepr` to an `Type[?]`
         *
         *  Usage:
-        *  ```scala sc:usingquotes
-        *  val typeRepr: TypeRepr = ???
-        *  typeRepr.asType match
-        *    case '[t] =>
-        *      '{ val x: t = ??? }
+        *  ```scala
+        *  //{
+        *  def f(using Quotes) = {
+        *    val typeRepr: TypeRepr = ???
+        *  //}
+        *    typeRepr.asType match
+        *      case '[t] =>
+        *        '{ val x: t = ??? }
+        *  //{
+        *  }
+        *  //}
         *  ```
         */
         def asType: Type[?]

library/src/scala/quoted/Type.scala

@@ -26,13 +26,20 @@ object Type:
    *  Returns None if the type is not a singleton constant type.
    *
    *  Example usage:
-   *  ```scala sc:usingquotes
+   *  ```scala
+   *  //{
    *  import scala.deriving.*
-   *  import quotes.reflect.*
-   *  val expr: Expr[Any] = ???
-   *  expr match
-   *    case '{ $mirrorExpr : Mirror.Sum { type MirroredLabel = label } } =>
-   *      Type.valueOfConstant[label] // Option[String]
+   *  def f(using Quotes) = {
+   *    import quotes.reflect.*
+   *    val expr: Expr[Any] = ???
+   *  //}
+   *    expr match {
+   *      case '{ $mirrorExpr : Mirror.Sum { type MirroredLabel = label } } =>
+   *        Type.valueOfConstant[label] // Option[String]
+   *    }
+   *  //{
+   *  }
+   *  //}
    *  ```
    */
   def valueOfConstant[T](using Type[T])(using Quotes): Option[T] =
@@ -43,14 +50,20 @@ object Type:
    *  Returns None if the type is not a tuple singleton constant types.
    *
    *  Example usage:
-   *  ```scala sc:usingquotes
+   *  ```scala
    *  //{
    *  import scala.deriving.*
-   *  import quotes.reflect.*
-   *  val expr: Expr[Any] = ???
-   *  expr match
-   *    case '{ type label <: Tuple; $mirrorExpr : Mirror.Sum { type MirroredElemLabels = `label` } } =>
-   *      Type.valueOfTuple[label] // Option[Tuple]
+   *  def f(using Quotes) = {
+   *    import quotes.reflect.*
+   *    val expr: Expr[Any] = ???
+   *  //}
+   *    expr match {
+   *      case '{ type label <: Tuple; $mirrorExpr : Mirror.Sum { type MirroredElemLabels = `label` } } =>
+   *        Type.valueOfTuple[label] // Option[Tuple]
+   *    }
+   *  //{
+   *  }
+   *  //}
    *  ```
    */
   @since("3.1")

library/src/scala/quoted/Varargs.scala

@@ -16,9 +16,15 @@ object Varargs {
    *    `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]`
    *
    *  Usage:
-   *  ```scala sc:usingquotes
-   *  import quotes.reflect.*
-   *  '{ List(${Varargs(List('{1}, '{2}, '{3}))}: _*) } // equivalent to '{ List(1, 2, 3) }
+   *  ```scala
+   *  //{
+   *  def f(using Quotes) = {
+   *    import quotes.reflect.*
+   *  //}
+   *    '{ List(${Varargs(List('{1}, '{2}, '{3}))}: _*) } // equivalent to '{ List(1, 2, 3) }
+   *  //{
+   *  }
+   *  //}
    *  ```
    */
   def apply[T](xs: Seq[Expr[T]])(using Type[T])(using Quotes): Expr[Seq[T]] = {

scaladoc-testcases/src/tests/snippetCompilerTests.scala

@@ -56,21 +56,15 @@ class B { }
 
 /**
  * ```scala sc:macrocompile
- *    inline def sum(args: Int*): Int = ${ sumExpr('args) }
- *    def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] = argsExpr match
- *      case Varargs(Exprs(args)) => ???
- *        // args: Seq[Int]
+ * import scala.quoted._
+ * inline def sum(args: Int*): Int = ${ sumExpr('args) }
+ * def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] = argsExpr match
+ *   case Varargs(Exprs(args)) => ???
+ *   // args: Seq[Int]
  * ```
  */
-class C { }
 
-/**
-   * ```scala sc:usingquotes
-   *    import quotes.reflect.*
-   *    '{ List(${Varargs(List('{1}, '{2}, '{3}))}: _*) } // equivalent to '{ List(1, 2, 3) }
-   * ```
-   */
-class D { }
+class C { }
 
 trait Quotes {
   val reflect: reflectModule = ???

scaladoc/src/dotty/tools/scaladoc/snippets/SnippetChecker.scala

@@ -44,28 +44,19 @@ class SnippetChecker(val args: Scaladoc.Args)(using cctx: CompilerContext):
     lineOffset: SnippetChecker.LineOffset,
     sourceFile: SourceFile
   ): Option[SnippetCompilationResult] = {
-    arg.flag match 
-      case flag @ (SCFlags.Compile | SCFlags.Fail | SCFlags.UsingQuotes) => 
-        val wrapped = WrappedSnippet(
-          snippet,
-          data.map(_.packageName),
-          data.fold(Nil)(_.classInfos),
-          data.map(_.imports).getOrElse(Nil),
-          lineOffset + data.fold(0)(_.position.line) + constantLineOffset,
-          data.fold(0)(_.position.column) + constantColumnOffset,
-          flag == SCFlags.UsingQuotes
-        )
-        Some(compiler.compile(wrapped, arg, sourceFile))
-      case SCFlags.MacroCompile =>
-        val wrapped = WrappedSnippet(
-          snippet, 
-          data.map(_.packageName),
-          data.map(_.imports).getOrElse(Nil),
-          lineOffset + data.fold(0)(_.position.line) + constantLineOffset,
-          data.fold(0)(_.position.column) + constantColumnOffset
-        )
-        Some(compiler.compile(wrapped, arg, sourceFile))
-      case SCFlags.NoCompile => None
+    if arg.flag != SCFlags.NoCompile then
+      val wrapped = WrappedSnippet(
+        snippet,
+        data.map(_.packageName),
+        data.fold(Nil)(_.classInfos),
+        data.map(_.imports).getOrElse(Nil),
+        lineOffset + data.fold(0)(_.position.line) + constantLineOffset,
+        data.fold(0)(_.position.column) + constantColumnOffset,
+        arg.flag
+      )
+      Some(compiler.compile(wrapped, arg, sourceFile))
+    else
+      None
 
   }
 

scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompilerArgs.scala

@@ -9,7 +9,6 @@ case class SnippetCompilerArg(flag: SCFlags):
 enum SCFlags(val flagName: String):
   case Compile extends SCFlags("compile")
   case MacroCompile extends SCFlags("macrocompile")
-  case UsingQuotes extends SCFlags("usingquotes")
   case NoCompile extends SCFlags("nocompile")
   case Fail extends SCFlags("fail")
 
@@ -39,8 +38,7 @@ object SnippetCompilerArgs:
     |
     |Available flags:
     |compile - Enables snippet checking.
-    |macrocompile - Enables snippet checking for macros. 
-    |usingquotes - Enables checking snippet additionally wrapped in `scala.quoted.Quotes` impilicit scope.
+    |macrocompile - Enables snippet checking for macros.
     |nocompile - Disables snippet checking.
     |fail - Enables snippet checking, asserts that snippet doesn't compile.
     |

scaladoc/src/dotty/tools/scaladoc/snippets/WrappedSnippet.scala

@@ -10,52 +10,49 @@ object WrappedSnippet:
 
   val indent: Int = 2
 
-  def apply(
-    str: String,
-    packageName: Option[String],
-    imports: List[String],
-    outerLineOffset: Int,
-    outerColumnOffset: Int
-  ): WrappedSnippet =
-    apply(str, packageName, Nil, imports, outerLineOffset, outerColumnOffset)
-
   def apply(
     str: String,
     packageName: Option[String],
     classInfos: Seq[SnippetCompilerData.ClassInfo],
     imports: List[String],
     outerLineOffset: Int,
     outerColumnOffset: Int,
-    usingQuotes: Boolean = false
+    flag: SCFlags,
   ): WrappedSnippet =
     val baos = new ByteArrayOutputStream()
     val ps = new PrintStream(baos)
     ps.startHide()
     ps.println(s"package ${packageName.getOrElse("snippets")}")
     imports.foreach(i => ps.println(s"import $i"))
-    val nestLevels = if classInfos.isEmpty then 1 else classInfos.length + (if usingQuotes then 1 else 0)
-    if classInfos.isEmpty then 
+    val nonEmptyClassInfos = if classInfos.isEmpty then Seq(SnippetCompilerData.ClassInfo(None, Nil, None)) else classInfos
+
+    if flag == SCFlags.MacroCompile then
       ps.println("object Snippet {")
     else
-      classInfos.zipWithIndex.foreach { (info, i) =>
+      nonEmptyClassInfos.zipWithIndex.foreach { (info, i) =>
         ps.printlnWithIndent(indent * i, s"trait Snippet$i${info.generics.getOrElse("")} { ${info.tpe.fold("")(cn => s"self: $cn =>")}")
         info.names.foreach{ name =>
           ps.printlnWithIndent(indent * i + indent, s"val $name = self")
         }
       }
-    if usingQuotes then 
-      ps.printlnWithIndent(classInfos.length * indent, "def f(using Quotes) = {")
+
     ps.endHide()
-    str.split('\n').foreach(ps.printlnWithIndent(nestLevels * indent, _))
+    val (indentsMade, createdVals) = if flag == SCFlags.MacroCompile then
+      (1, 1)
+    else
+      (nonEmptyClassInfos.size, nonEmptyClassInfos.flatMap(_.names).size)
+
+    str.split('\n').foreach(ps.printlnWithIndent(indentsMade * indent, _))
     ps.startHide()
-    (0 to nestLevels -1).reverse.foreach( i => ps.printlnWithIndent(i * indent, "}"))
+    (0 to indentsMade -1).reverse.foreach( i => ps.printlnWithIndent(i * indent, "}"))
     ps.endHide()
+
     WrappedSnippet(
       baos.toString,
       outerLineOffset,
       outerColumnOffset,
-      nestLevels + classInfos.flatMap(_.names).size + packageName.size + 2 /*Hide tokens*/,
-      nestLevels * indent
+      indentsMade + imports.length + createdVals + packageName.size + 2 /*Hide tokens*/,
+      indentsMade * indent
     )
 
   extension (ps: PrintStream)