Fix markdown syntax for scala3 library docstrings

library/src/scala/Tuple.scala

@@ -126,13 +126,14 @@ object Tuple {
 
   /** Filters out those members of the tuple for which the predicate `P` returns `false`.
    *  A predicate `P[X]` is a type that can be either `true` or `false`. For example:
-   *  ```
+   *  ```scala
    *  type IsString[x] = x match {
    *    case String => true
    *    case _ => false
    *  }
    *  Filter[(1, "foo", 2, "bar"), IsString] =:= ("foo", "bar")
-   * ```
+   *  ```
+   *  @syntax markdown
    */
   type Filter[Tup <: Tuple, P[_] <: Boolean] <: Tuple = Tup match {
     case EmptyTuple => EmptyTuple

library/src/scala/compiletime/ops/any.scala

@@ -8,6 +8,7 @@ object any:
    * val eq2: 1 == "1" = false
    * val eq3: "1" == "1" = true
    * ```
+   * @syntax markdown
    */
   type ==[X, Y] <: Boolean
 
@@ -17,5 +18,6 @@ object any:
    * val eq2: 1 != "1" = true
    * val eq3: "1" != "1" = false
    * ```
+   * @syntax markdown
    */
   type !=[X, Y] <: Boolean

library/src/scala/compiletime/ops/boolean.scala

@@ -8,14 +8,16 @@ object boolean:
    *  val notFalse: ![false] = true
    *  val notTrue: ![true] = false
    *  ```
+   *  @syntax markdown
    */
   type ![X <: Boolean] <: Boolean
 
   /** Exclusive disjunction of two `Boolean` singleton types.
-   * ```scala
-   * val a: true ^ true = false
-   * val b: false ^ true = true
-   * ```
+   *  ```scala
+   *  val a: true ^ true = false
+   *  val b: false ^ true = true
+   *  ```
+   *  @syntax markdown
    */
   type ^[X <: Boolean, Y <: Boolean] <: Boolean
 
@@ -24,13 +26,15 @@ object boolean:
    *  val a: true && true = true
    *  val b: false && true = false
    *  ```
+   *  @syntax markdown
    */
   type &&[X <: Boolean, Y <: Boolean] <: Boolean
 
   /** Disjunction of two `Boolean` singleton types.
-   * ```scala
-   * val a: true || false = true
-   * val b: false || false = false
-   * ```
+   *  ```scala
+   *  val a: true || false = true
+   *  val b: false || false = false
+   *  ```
+   *  @syntax markdown
    */
   type ||[X <: Boolean, Y <: Boolean] <: Boolean

library/src/scala/compiletime/ops/int.scala

@@ -6,62 +6,71 @@ object int:
    *  ```scala
    *  val sum: 2 + 2 = 4
    *  ```
+   *  @syntax markdown
    */
   type +[X <: Int, Y <: Int] <: Int
 
   /** Subtraction of two `Int` singleton types.
    *  ```scala
    *  val sub: 4 - 2 = 2
    *  ```
+   *  @syntax markdown
    */
   type -[X <: Int, Y <: Int] <: Int
 
   /** Multiplication of two `Int` singleton types.
    *  ```scala
    *  val mul: 4 * 2 = 8
    *  ```
+   *  @syntax markdown
    */
   type *[X <: Int, Y <: Int] <: Int
 
   /** Integer division of two `Int` singleton types.
    *  ```scala
    *  val div: 5 / 2 = 2
    *  ```
+   *  @syntax markdown
    */
   type /[X <: Int, Y <: Int] <: Int
 
   /** Remainder of the division of `X` by `Y`.
    *  ```scala
    *  val mod: 5 % 2 = 1
    *  ```
+   *  @syntax markdown
    */
   type %[X <: Int, Y <: Int] <: Int
 
   /** Binary left shift of `X` by `Y`.
    *  ```scala
    *  val lshift: 1 << 2 = 4
    *  ```
+   *  @syntax markdown
    */
   type <<[X <: Int, Y <: Int] <: Int
 
   /** Binary right shift of `X` by `Y`.
    *  ```scala
    *  val rshift: 10 >> 1 = 5
    *  ```
+   *  @syntax markdown
    */
   type >>[X <: Int, Y <: Int] <: Int
 
   /** Binary right shift of `X` by `Y`, filling the left with zeros.
    *  ```scala
    *  val rshiftzero: 10 >>> 1 = 5
    *  ```
+   *  @syntax markdown
    */
   type >>>[X <: Int, Y <: Int] <: Int
 
   /** Bitwise xor of `X` and `Y`.
    *  ```scala
    *  val xor: 10 ^ 30 = 20
    *  ```
+   *  @syntax markdown
    */
   type ^[X <: Int, Y <: Int] <: Int
 
@@ -70,6 +79,7 @@ object int:
    *  val lt1: 4 < 2 = false
    *  val lt2: 2 < 4 = true
    *  ```
+   *  @syntax markdown
    */
   type <[X <: Int, Y <: Int] <: Boolean
 
@@ -78,6 +88,7 @@ object int:
    *  val gt1: 4 > 2 = true
    *  val gt2: 2 > 2 = false
    *  ```
+   *  @syntax markdown
    */
   type >[X <: Int, Y <: Int] <: Boolean
 
@@ -86,6 +97,7 @@ object int:
    *  val ge1: 4 >= 2 = true
    *  val ge2: 2 >= 3 = false
    *  ```
+   *  @syntax markdown
    */
   type >=[X <: Int, Y <: Int] <: Boolean
 
@@ -94,6 +106,7 @@ object int:
    *  val lt1: 4 <= 2 = false
    *  val lt2: 2 <= 2 = true
    *  ```
+   *  @syntax markdown
    */
   type <=[X <: Int, Y <: Int] <: Boolean
 
@@ -102,20 +115,23 @@ object int:
    *  val and1: BitwiseAnd[4, 4] = 4
    *  val and2: BitwiseAnd[10, 5] = 0
    *  ```
+   *  @syntax markdown
    */
   type BitwiseAnd[X <: Int, Y <: Int] <: Int
 
   /** Bitwise or of `X` and `Y`.
    *  ```scala
    *  val or: BitwiseOr[10, 11] = 11
    *  ```
+   *  @syntax markdown
    */
   type BitwiseOr[X <: Int, Y <: Int] <: Int
 
   /** Absolute value of an `Int` singleton type.
    *  ```scala
    *  val abs: Abs[-1] = 1
    *  ```
+   *  @syntax markdown
    */
   type Abs[X <: Int] <: Int
 
@@ -124,26 +140,30 @@ object int:
    *  val neg1: Neg[-1] = 1
    *  val neg2: Neg[1] = -1
    *  ```
+   *  @syntax markdown
    */
   type Negate[X <: Int] <: Int
 
   /** Minimum of two `Int` singleton types.
    *  ```scala
    *  val min: Min[-1, 1] = -1
    *  ```
+   *  @syntax markdown
    */
   type Min[X <: Int, Y <: Int] <: Int
 
   /** Maximum of two `Int` singleton types.
    *  ```scala
    *  val max: Max[-1, 1] = 1
    *  ```
+   *  @syntax markdown
    */
   type Max[X <: Int, Y <: Int] <: Int
 
   /** String conversion of an `Int` singleton type.
    *  ```scala
    *  val abs: ToString[1] = "1"
    *  ```
+   *  @syntax markdown
    */
   type ToString[X <: Int] <: String

library/src/scala/compiletime/ops/string.scala

@@ -6,5 +6,6 @@ object string:
    *  ```scala
    *  val hello: "hello " + "world" = "hello world"
    *  ```
+   *  @syntax markdown
    */
   type +[X <: String, Y <: String] <: String

library/src/scala/compiletime/package.scala

@@ -6,14 +6,15 @@ package object compiletime {
   /** Use this method when you have a type, do not have a value for it but want to
    *  pattern match on it. For example, given a type `Tup <: Tuple`, one can
    *  pattern-match on it as follows:
-   *  ```
+   *  ```scala
    *  inline erasedValue[Tup] match {
    *    case _: EmptyTuple => ...
    *    case _: h *: t => ...
    *  }
    *  ```
    *  This value can only be used in an inline match and the value cannot be used in
    *  the branches.
+   *  @syntax markdown
    */
   erased def erasedValue[T]: T = ???
 
@@ -39,6 +40,7 @@ package object compiletime {
    *  inline def errorOnThisCode(inline x: Any) =
    *    error("My error of this code: " + codeOf(x))
    *  ```
+   *  @syntax markdown
    */
   inline def error(inline msg: String): Nothing = ???
 
@@ -55,8 +57,10 @@ package object compiletime {
    *
    *  The formatting of the code is not stable across version of the compiler.
    *
-   * @note only `inline` arguments will be displayed as "code".
-   *       Other values may display unintutively.
+   *  @note only `inline` arguments will be displayed as "code".
+   *        Other values may display unintutively.
+   *
+   *  @syntax markdown
    */
   transparent inline def codeOf(arg: Any): String =
     // implemented in dotty.tools.dotc.typer.Inliner.Intrinsics
@@ -75,6 +79,7 @@ package object compiletime {
    *  val m: Int = ...
    *  twice(m) // error: expected a constant value but found: m
    *  ```
+   *  @syntax markdown
    */
   inline def requireConst(inline x: Boolean | Byte | Short | Int | Long | Float | Double | Char | String): Unit =
     // implemented in dotty.tools.dotc.typer.Inliner
@@ -97,10 +102,11 @@ package object compiletime {
 
   /**
    * Use this type to widen a self-type to a tuple. E.g.
-   * ```
+   * ```scala
    * val x: (1, 3) = (1, 3)
    * val y: Widen[x.type] = x
    * ```
+   * @syntax markdown
    */
   type Widen[Tup <: Tuple] <: Tuple = Tup match {
     case EmptyTuple => EmptyTuple
@@ -121,16 +127,18 @@ package object compiletime {
 
   /** Summons first given matching one of the listed cases. E.g. in
    *
-   *      given B { ... }
-   *
-   *      summonFrom {
-   *        case given A => 1
-   *        case given B => 2
-   *        case given C => 3
-   *        case _ => 4
-   *      }
+   *  ```scala
+   *  given B { ... }
    *
+   *  summonFrom {
+   *    case given A => 1
+   *    case given B => 2
+   *    case given C => 3
+   *    case _ => 4
+   *  }
+   *  ```
    *  the returned value would be `2`.
+   *  @syntax markdown
    */
   transparent inline def summonFrom[T](f: Nothing => T): T =
     error("Compiler bug: `summonFrom` was not evaluated by the compiler")
@@ -162,13 +170,16 @@ package object compiletime {
 
   /** Succesor of a natural number where zero is the type 0 and successors are reduced as if the definition was
    *
-   *      type S[N <: Int] <: Int = N match {
-   *        case 0 => 1
-   *        case 1 => 2
-   *        case 2 => 3
-   *        ...
-   *        case 2147483646 => 2147483647
-   *      }
+   *  ```scala
+   *  type S[N <: Int] <: Int = N match {
+   *    case 0 => 1
+   *    case 1 => 2
+   *    case 2 => 3
+   *    ...
+   *    case 2147483646 => 2147483647
+   *  }
+   *  ```
+   *  @syntax markdown
    */
   type S[N <: Int] <: Int
 

library/src/scala/quoted/Expr.scala

@@ -40,13 +40,14 @@ object Expr {
    *  Otherwise returns `None`.
    *
    *  Usage:
-   *  ```
+   *  ```scala
    *  case '{ ... ${expr @ Expr(value)}: T ...} =>
    *    // expr: Expr[T]
    *    // value: T
    *  ```
    *
    *  To directly get the value of an expression `expr: Expr[T]` consider using `expr.value`/`expr.valueOrError` insead.
+   *  @syntax markdown
    */
   def unapply[T](x: Expr[T])(using FromExpr[T])(using Quotes): Option[T] =
     scala.Predef.summon[FromExpr[T]].unapply(x)
@@ -57,7 +58,6 @@ object Expr {
    *    `Seq(e1, e2, ...)` where `ei: Expr[T]`
    *  to an expression equivalent to
    *    `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]`
-   *  ```
    */
   def ofSeq[T](xs: Seq[Expr[T]])(using Type[T])(using Quotes): Expr[Seq[T]] =
     Varargs(xs)