Address other review suggestions

Author: odersky

docs/docs/internals/explicit-nulls.md

@@ -111,30 +111,25 @@ The reason for casting to `x.type & T`, as opposed to just `T`, is that it allow
 support flow typing for paths of length greater than one.
 
 ```scala
-abstract class Node {
-  val x: String
-  val next: Node | Null
-}
-
-def f = {
-  val l: Node|Null = ???
-  if (l != null && l.next != null) {
-    val third: l.next.next.type = l.next.next
-  }
-}
+abstract class Node:
+   val x: String
+   val next: Node | Null
+
+def f =
+   val l: Node|Null = ???
+   if l != null && l.next != null then
+      val third: l.next.next.type = l.next.next
 ```
 
 After typing, `f` becomes:
 
 ```scala
-def f = {
-  val l: Node|Null = ???
-  if (l != null && l.$asInstanceOf$[l.type & Node].next != null) {
-    val third:
-      l.$asInstanceOf$[l.type & Node].next.$asInstanceOf$[(l.type & Node).next.type & Node].next.type =
-      l.$asInstanceOf$[l.type & Node].next.$asInstanceOf$[(l.type & Node).next.type & Node].next
-  }
-}
+def f =
+   val l: Node|Null = ???
+   if l != null && l.$asInstanceOf$[l.type & Node].next != null then
+      val third:
+         l.$asInstanceOf$[l.type & Node].next.$asInstanceOf$[(l.type & Node).next.type & Node].next.type =
+         l.$asInstanceOf$[l.type & Node].next.$asInstanceOf$[(l.type & Node).next.type & Node].next
 ```
 Notice that in the example above `(l.type & Node).next.type & Node` is still a stable path, so
 we can use it in the type and track it for flow typing.

docs/docs/reference/metaprogramming/macros.md

@@ -466,8 +466,8 @@ inline def power(x: Double, inline n: Int) = ${ powerCode('x, 'n) }
 
 private def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
    n.value match
-   case Some(m) => powerCode(x, m)
-   case None => '{ Math.pow($x, $n.toDouble) }
+      case Some(m) => powerCode(x, m)
+      case None => '{ Math.pow($x, $n.toDouble) }
 
 private def powerCode(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
    if n == 0 then '{ 1.0 }
@@ -613,8 +613,8 @@ inline def setFor[T]: Set[T] = ${ setForExpr[T] }
 
 def setForExpr[T: Type](using Quotes): Expr[Set[T]] =
    Expr.summon[Ordering[T]] match
-   case Some(ord) => '{ new TreeSet[T]()($ord) }
-   case _ => '{ new HashSet[T] }
+      case Some(ord) => '{ new TreeSet[T]()($ord) }
+      case _ => '{ new HashSet[T] }
 ```
 
 ## Relationship with Whitebox Inline
@@ -628,8 +628,8 @@ transparent inline def defaultOf(inline str: String) = ${ defaultOfImpl('str) }
 
 def defaultOfImpl(strExpr: Expr[String])(using Quotes): Expr[Any] =
    strExpr.valueOrError match
-   case "int" => '{1}
-   case "string" => '{"a"}
+      case "int" => '{1}
+      case "string" => '{"a"}
 
 // in a separate file
 val a: Int = defaultOf("int")
@@ -665,16 +665,16 @@ These could be used in the following way to optimize any call to `sum` that has
 inline def sum(inline args: Int*): Int = ${ sumExpr('args) }
 private def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] =
    argsExpr match
-   case Varargs(args @ Exprs(argValues)) =>
-      // args is of type Seq[Expr[Int]]
-      // argValues is of type Seq[Int]
-      Expr(argValues.sum) // precompute result of sum
-   case Varargs(argExprs) => // argExprs is of type Seq[Expr[Int]]
-      val staticSum: Int = argExprs.map(_.value.getOrElse(0)).sum
-      val dynamicSum: Seq[Expr[Int]] = argExprs.filter(_.value.isEmpty)
-      dynamicSum.foldLeft(Expr(staticSum))((acc, arg) => '{ $acc + $arg })
-   case _ =>
-      '{ $argsExpr.sum }
+      case Varargs(args @ Exprs(argValues)) =>
+         // args is of type Seq[Expr[Int]]
+         // argValues is of type Seq[Int]
+         Expr(argValues.sum) // precompute result of sum
+      case Varargs(argExprs) => // argExprs is of type Seq[Expr[Int]]
+         val staticSum: Int = argExprs.map(_.value.getOrElse(0)).sum
+         val dynamicSum: Seq[Expr[Int]] = argExprs.filter(_.value.isEmpty)
+         dynamicSum.foldLeft(Expr(staticSum))((acc, arg) => '{ $acc + $arg })
+      case _ =>
+         '{ $argsExpr.sum }
 ```
 
 ### Quoted patterns

docs/docs/reference/other-new-features/explicit-nulls.md

@@ -106,8 +106,8 @@ Specifically, we patch
 
     ```java
     class C {
-      String s;
-      int x;
+       String s;
+       int x;
     }
     ```
     ==>
@@ -183,12 +183,13 @@ Specifically, we patch
   * We don't nullify _simple_ literal constant (`final`) fields, since they are known to be non-null
 
     ```java
-    class Constants:
+    class Constants {
        final String NAME = "name";
        final int AGE = 0;
        final char CHAR = 'a';
 
        final String NAME_GENERATED = getNewName();
+    }
     ```
     ==>
     ```scala
@@ -204,10 +205,11 @@ Specifically, we patch
     `NotNull` annotation.
 
     ```java
-    class C:
+    class C {
        @NotNull String name;
        @NotNull List<String> getNames(String prefix); // List is Java-defined
        @NotNull Box<String> getBoxedName(); // Box is Scala-defined
+    }
     ```
     ==>
     ```scala