Change code blocks to use indentation instead of backticks. (#1351)

Not exactly the most impactful change. :) But in a previous PR, Nate
suggested that old-style Markdown indentation for code blocks would be
better than backticks since it's shorter and we aren't actually running
the comments through a Markdown formatter anyway.

This converts all of them over in on Go so the codebase is consistent.

Author: munificent

lib/src/ast_extensions.dart

@@ -131,27 +131,21 @@ extension ExpressionExtensions on Expression {
   /// example, in an assignment, a split in the assigned value is usually
   /// indented:
   ///
-  /// ```
-  /// var variableName =
-  ///     longValue;
-  /// ```
+  ///     var variableName =
+  ///         longValue;
   ///
   /// But if the initializer is block-like, we don't split at the `=`:
   ///
-  /// ```
-  /// var variableName = [
-  ///   element,
-  /// ];
-  /// ```
+  ///     var variableName = [
+  ///       element,
+  ///     ];
   ///
   /// Likewise, in an argument list, block-like expressions can avoid splitting
   /// the surrounding argument list:
   ///
-  /// ```
-  /// function([
-  ///   element,
-  /// ]);
-  /// ```
+  ///     function([
+  ///       element,
+  ///     ]);
   ///
   /// Completely empty delimited constructs like `[]` and `foo()` don't allow
   /// splitting inside them, so are not considered block-like.
@@ -165,21 +159,17 @@ extension ExpressionExtensions on Expression {
     // TODO(tall): We should also allow multi-line strings to be formatted
     // like block arguments, at least in some cases like:
     //
-    // ```
-    // function('''
-    //   Lots of
-    //   text
-    // ''');
-    // ```
+    //     function('''
+    //       Lots of
+    //       text
+    //     ''');
 
     // TODO(tall): Consider whether immediately-invoked function expressions
     // should be block argument candidates, like:
     //
-    // ```
-    // function(() {
-    //   body;
-    // }());
-    // ```
+    //     function(() {
+    //       body;
+    //     }());
     return switch (expression) {
       // A function expression can use either a non-empty parameter list or a
       // non-empty block body for block formatting.

lib/src/comment_type.dart

@@ -20,9 +20,7 @@ enum CommentType {
   /// preceding the `/*`, after the `*/`, or both. An inline block comment
   /// may be multiple lines, as in:
   ///
-  /// ```
-  /// code /* comment
-  ///   more */
-  /// ```
+  ///     code /* comment
+  ///       more */
   inlineBlock,
 }

lib/src/front_end/ast_node_visitor.dart

@@ -631,9 +631,7 @@ class AstNodeVisitor extends ThrowingAstVisitor<Piece> with PieceFactory {
     if (node.parameters case var parameters?) {
       // A function-typed field formal like:
       //
-      // ```
-      // C(this.fn(parameter));
-      // ```
+      //     C(this.fn(parameter));
       return createFunctionType(
           node.type,
           fieldKeyword: node.thisKeyword,
@@ -721,15 +719,13 @@ class AstNodeVisitor extends ThrowingAstVisitor<Piece> with PieceFactory {
         // where each clause is a separate argument. This means that when they
         // split, they split like:
         //
-        // ```
-        // for (
-        //   initializerClause;
-        //   conditionClause;
-        //   incrementClause
-        // ) {
-        //   body;
-        // }
-        // ```
+        //     for (
+        //       initializerClause;
+        //       conditionClause;
+        //       incrementClause
+        //     ) {
+        //       body;
+        //     }
         var partsList =
             DelimitedListBuilder(this, const ListStyle(commas: Commas.none));
         partsList.leftBracket(node.leftParenthesis);
@@ -779,13 +775,11 @@ class AstNodeVisitor extends ThrowingAstVisitor<Piece> with PieceFactory {
         // If a for-in loop, treat the for parts like an assignment, so they
         // split like:
         //
-        // ```
-        // for (var variable in [
-        //   initializer,
-        // ]) {
-        //   body;
-        // }
-        // ```
+        //     for (var variable in [
+        //       initializer,
+        //     ]) {
+        //       body;
+        //     }
         forPartsPiece = buildPiece((b) {
           b.token(node.leftParenthesis);
           b.add(createAssignment(
@@ -1039,12 +1033,10 @@ class AstNodeVisitor extends ThrowingAstVisitor<Piece> with PieceFactory {
       // Edge case: When the then branch is a block and there is an else clause
       // after it, we want to force the block to split even if empty, like:
       //
-      // ```
-      // if (condition) {
-      // } else {
-      //   body;
-      // }
-      // ```
+      //     if (condition) {
+      //     } else {
+      //       body;
+      //     }
       var thenStatement = switch (ifStatement.thenStatement) {
         Block thenBlock when ifStatement.elseStatement != null =>
           createBlock(thenBlock, forceSplit: true),
@@ -1589,9 +1581,7 @@ class AstNodeVisitor extends ThrowingAstVisitor<Piece> with PieceFactory {
     if (node.parameters case var parameters?) {
       // A function-typed super parameter like:
       //
-      // ```
-      // C(super.fn(parameter));
-      // ```
+      //     C(super.fn(parameter));
       return createFunctionType(
           node.type,
           fieldKeyword: node.superKeyword,

lib/src/front_end/comment_writer.dart

@@ -193,15 +193,13 @@ class SourceComment {
 ///
 /// For example, this code:
 ///
-/// ```dart
-/// a /* c1 */
-/// /* c2 */
+///     a /* c1 */
+///     /* c2 */
 ///
-/// /* c3 */
+///     /* c3 */
 ///
 ///
-/// b
-/// ```
+///     b
 ///
 /// Produces a sequence like:
 ///

lib/src/front_end/delimited_list_builder.dart

@@ -67,9 +67,7 @@ class DelimitedListBuilder {
   /// after [bracket]. This is used for parameter lists where all parameters
   /// are optional or named, as in:
   ///
-  /// ```
-  /// function([parameter]);
-  /// ```
+  ///     function([parameter]);
   ///
   /// Here, [bracket] will be `(` and [delimiter] will be `[`.
   void leftBracket(Token bracket, {Piece? preceding, Token? delimiter}) {
@@ -90,9 +88,7 @@ class DelimitedListBuilder {
   /// after [bracket]. This is used for parameter lists with optional or named
   /// parameters, like:
   ///
-  /// ```
-  /// function(mandatory, {named});
-  /// ```
+  ///     function(mandatory, {named});
   ///
   /// Here, [bracket] will be `)` and [delimiter] will be `}`.
   ///
@@ -107,13 +103,11 @@ class DelimitedListBuilder {
     // bracket. If there is a delimiter, this will move comments between it and
     // the bracket to before the delimiter, as in:
     //
-    // ```
-    // // Before:
-    // f([parameter] /* comment */) {}
+    //     // Before:
+    //     f([parameter] /* comment */) {}
     //
-    // // After:
-    // f([parameter /* comment */]) {}
-    // ```
+    //     // After:
+    //     f([parameter /* comment */]) {}
     if (delimiter != null) {
       commentsBefore = _visitor.comments
           .takeCommentsBefore(delimiter)
@@ -188,15 +182,11 @@ class DelimitedListBuilder {
     // Preserve any comments before the delimiter. Treat them as occurring
     // before the previous element's comma. This means that:
     //
-    // ```
-    // function(p1, /* comment */ [p1]);
-    // ```
+    //     function(p1, /* comment */ [p1]);
     //
     // Will be formatted as:
     //
-    // ```
-    // function(p1 /* comment */, [p1]);
-    // ```
+    //     function(p1 /* comment */, [p1]);
     //
     // (In practice, it's such an unusual place for a comment that it doesn't
     // matter that much where it goes and this seems to be simple and
@@ -280,13 +270,11 @@ class DelimitedListBuilder {
   ///
   /// For example:
   ///
-  /// ```
-  /// function(
-  ///   argument /* inline */, // hanging
-  ///   // separate
-  ///   /* leading */ nextArgument
-  /// );
-  /// ```
+  ///     function(
+  ///       argument /* inline */, // hanging
+  ///       // separate
+  ///       /* leading */ nextArgument
+  ///     );
   ///
   /// Calculating these takes into account whether there are newlines before or
   /// after the comments, and which side of the commas the comments appear on.
@@ -322,12 +310,10 @@ class DelimitedListBuilder {
     // Inline block comments before the `,` stay with the preceding element, as
     // in:
     //
-    // ```
-    // function(
-    //   argument /* hanging */ /* comment */,
-    //   argument,
-    // );
-    // ```
+    //     function(
+    //       argument /* hanging */ /* comment */,
+    //       argument,
+    //     );
     var inlineCommentCount = 0;
     if (_elements.isNotEmpty) {
       while (inlineCommentCount < _commentsBeforeComma.length) {
@@ -361,12 +347,10 @@ class DelimitedListBuilder {
     // Inline block comments on the same line as the next element lead at the
     // beginning of that line, as in:
     ///
-    // ```
-    // function(
-    //   argument,
-    //   /* leading */ /* comment */ argument,
-    // );
-    // ```
+    //     function(
+    //       argument,
+    //       /* leading */ /* comment */ argument,
+    //     );
     var leadingCommentCount = 0;
     if (hasElementAfter && commentsBeforeElement.isNotEmpty) {
       while (leadingCommentCount < commentsBeforeElement.length) {
@@ -386,14 +370,12 @@ class DelimitedListBuilder {
     // Comments that are neither hanging nor leading are formatted like
     // separate elements, as in:
     //
-    // ```
-    // function(
-    //   argument,
-    //   /* comment */
-    //   argument,
-    //   // another
-    // );
-    // ```
+    //     function(
+    //       argument,
+    //       /* comment */
+    //       argument,
+    //       // another
+    //     );
     var separateComments =
         separateCommentsBeforeComma.concatenate(separateCommentsAfterComma);
 
@@ -433,13 +415,11 @@ class DelimitedListBuilder {
     // be it.
     // TODO(tall): The old formatter allows multiple block arguments, like:
     //
-    // ```
-    // function(() {
-    //   body;
-    // }, () {
-    //   more;
-    // });
-    // ```
+    //     function(() {
+    //       body;
+    //     }, () {
+    //       more;
+    //     });
     //
     // This doesn't seem very common in the Flutter repo, but does occur
     // sometimes. We'll probably want to experiment to see if it's worth

lib/src/front_end/piece_factory.dart

@@ -71,10 +71,8 @@ mixin PieceFactory {
   /// is used, for example, with empty blocks in `if` statements followed by
   /// `else` clauses:
   ///
-  /// ```
-  /// if (condition) {
-  /// } else {}
-  /// ```
+  ///     if (condition) {
+  ///     } else {}
   Piece createBody(
       Token leftBracket, List<AstNode> contents, Token rightBracket,
       {bool forceSplit = false}) {
@@ -104,10 +102,8 @@ mixin PieceFactory {
   /// is used, for example, with empty blocks in `if` statements followed by
   /// `else` clauses:
   ///
-  /// ```
-  /// if (condition) {
-  /// } else {}
-  /// ```
+  ///     if (condition) {
+  ///     } else {}
   Piece createBlock(Block block, {bool forceSplit = false}) {
     return createBody(block.leftBracket, block.statements, block.rightBracket,
         forceSplit: forceSplit);
@@ -133,12 +129,10 @@ mixin PieceFactory {
       // TODO(tall): Support a line comment inside a collection literal as a
       // signal to preserve internal newlines. So if you have:
       //
-      // ```
-      // var list = [
-      //   1, 2, 3, // comment
-      //   4, 5, 6,
-      // ];
-      // ```
+      //     var list = [
+      //       1, 2, 3, // comment
+      //       4, 5, 6,
+      //     ];
       //
       // The formatter will preserve the newline after element 3 and the lack of
       // them after the other elements.
@@ -380,14 +374,12 @@ mixin PieceFactory {
       // Edge case: When there's another catch/on/finally after this one, we
       // want to force the block to split even if it's empty.
       //
-      // ```
-      // try {
-      //   ..
-      // } on Foo {
-      // } finally Bar {
-      //   body;
-      // }
-      // ```
+      //     try {
+      //       ..
+      //     } on Foo {
+      //     } finally Bar {
+      //       body;
+      //     }
       var forceSplit = i < tryStatement.catchClauses.length - 1 ||
           tryStatement.finallyBlock != null;
       var catchClauseBody =