diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift
index b0fe79e9a64..6b6b9316e49 100644
--- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift
@@ -152,13 +152,13 @@ public let COMMON_NODES: [Node] = [
       Child(
         name: "Attributes",
         kind: .collection(kind: .attributeList, collectionElementName: "Attribute"),
-        documentation: "If there were standalone attributes without a declaration to attach them to, the `MissingDeclSyntax` will contain these.",
+        documentation: "If there were standalone attributes without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these.",
         isOptional: true
       ),
       Child(
         name: "Modifiers",
         kind: .collection(kind: .modifierList, collectionElementName: "Modifier"),
-        documentation: "If there were standalone modifiers without a declaration to attach them to, the `MissingDeclSyntax` will contain these.",
+        documentation: "If there were standalone modifiers without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these.",
         isOptional: true
       ),
       Child(
diff --git a/CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift b/CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift
index 489d41b2a39..7416e2e4330 100644
--- a/CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift
@@ -707,7 +707,7 @@ public let EXPR_NODES: [Node] = [
     kind: .exprList,
     base: .syntaxCollection,
     nameForDiagnostics: nil,
-    documentation: "A list of expressions connected by operators. This list is contained by a `SequenceExprSyntax`.",
+    documentation: "A list of expressions connected by operators. This list is contained by a ``SequenceExprSyntax``.",
     elementChoices: [.expr]
   ),
 
diff --git a/CodeGeneration/Sources/Utils/CodeGenerationFormat.swift b/CodeGeneration/Sources/Utils/CodeGenerationFormat.swift
index 361cc90e06e..30d899f87d1 100644
--- a/CodeGeneration/Sources/Utils/CodeGenerationFormat.swift
+++ b/CodeGeneration/Sources/Utils/CodeGenerationFormat.swift
@@ -92,7 +92,7 @@ public class CodeGenerationFormat: BasicFormat {
   // MARK: - Private
 
   private func shouldBeSeparatedByTwoNewlines(node: CodeBlockItemSyntax) -> Bool {
-    // First item in the `CodeBlockItemListSyntax` don't need a newline or identation if the parent is a `SourceFileSyntax`.
+    // First item in the ``CodeBlockItemListSyntax`` don't need a newline or identation if the parent is a ``SourceFileSyntax``.
     // We want to group imports so newline between them should be omitted
     return node.parent?.as(CodeBlockItemListSyntax.self)?.first == node || node.item.is(ImportDeclSyntax.self)
   }
diff --git a/CodeGeneration/Sources/Utils/SyntaxBuildableChild.swift b/CodeGeneration/Sources/Utils/SyntaxBuildableChild.swift
index e56eb7a45f9..ab2ed97262e 100644
--- a/CodeGeneration/Sources/Utils/SyntaxBuildableChild.swift
+++ b/CodeGeneration/Sources/Utils/SyntaxBuildableChild.swift
@@ -21,10 +21,10 @@ public enum SyntaxOrTokenNodeKind: Hashable {
   case token(tokenKind: String)
 }
 
-/// Extension to the `Child` type to provide functionality specific to
+/// Extension to the ``Child`` type to provide functionality specific to
 /// SwiftSyntaxBuilder.
 public extension Child {
-  /// The type of this child, represented by a `SyntaxBuildableType`, which can
+  /// The type of this child, represented by a ``SyntaxBuildableType``, which can
   /// be used to create the corresponding `Buildable` and `ExpressibleAs` types.
   var type: SyntaxBuildableType {
     let buildableKind: SyntaxOrTokenNodeKind
@@ -96,7 +96,7 @@ public extension Child {
 
   /// If this node is a token that can't contain arbitrary text, generate a Swift
   /// `precondition` statement that verifies the variable with name var_name and of type
-  /// `TokenSyntax` contains one of the supported text options. Otherwise return `nil`.
+  /// ``TokenSyntax`` contains one of the supported text options. Otherwise return `nil`.
   func generateAssertStmtTextChoices(varName: String) -> FunctionCallExprSyntax? {
     guard case .token(choices: let choices, requiresLeadingSpace: _, requiresTrailingSpace: _) = kind else {
       return nil
diff --git a/CodeGeneration/Sources/Utils/SyntaxBuildableNode.swift b/CodeGeneration/Sources/Utils/SyntaxBuildableNode.swift
index fd71e8e1e3a..fdad0ae7bf1 100644
--- a/CodeGeneration/Sources/Utils/SyntaxBuildableNode.swift
+++ b/CodeGeneration/Sources/Utils/SyntaxBuildableNode.swift
@@ -12,15 +12,15 @@
 
 import SyntaxSupport
 
-/// Extension to the `Node` type to provide functionality specific to
+/// Extension to the ``Node`` type to provide functionality specific to
 /// SwiftSyntaxBuilder.
 public extension Node {
-  /// The node's syntax kind as `SyntaxBuildableType`.
+  /// The node's syntax kind as ``SyntaxBuildableType``.
   var type: SyntaxBuildableType {
     SyntaxBuildableType(kind: .node(kind: kind))
   }
 
-  /// The node's syntax kind as `SyntaxBuildableType`.
+  /// The node's syntax kind as ``SyntaxBuildableType``.
   var baseType: SyntaxBuildableType {
     if base == .syntaxCollection {
       return SyntaxBuildableType(kind: .node(kind: .syntax))
diff --git a/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift b/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift
index 1ccd72c2cd1..b4d93f06e10 100644
--- a/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift
+++ b/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift
@@ -86,7 +86,7 @@ public struct SyntaxBuildableType: Hashable {
   /// These names look as follows:
   ///  - For nodes: The node name, e.g. `IdentifierExpr` (these are implemented as structs)
   ///  - For base kinds: `<BaseKind>Buildable`, e.g. `ExprBuildable` (these are implemented as protocols)
-  ///  - For token: `TokenSyntax` (tokens don't have a dedicated type in SwiftSyntaxBuilder)
+  ///  - For token: ``TokenSyntax`` (tokens don't have a dedicated type in SwiftSyntaxBuilder)
   /// If the type is optional, the type is wrapped in an `OptionalType`.
   public var buildable: TypeSyntax {
     optionalWrapped(type: SimpleTypeIdentifierSyntax(name: .identifier(syntaxBaseName)))
diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/KeywordFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/KeywordFile.swift
index b52b40342ff..285fd0327e6 100644
--- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/KeywordFile.swift
+++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/KeywordFile.swift
@@ -54,7 +54,7 @@ let keywordFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       /// This is really unfortunate. Really, we should have a `switch` in
       /// `Keyword.defaultText` to return the keyword's kind but the constant lookup
       /// table is significantly faster. Ideally, we could also get the compiler to
-      /// constant-evaluate `Keyword.spi.defaultText` to a `SyntaxText` but I don't
+      /// constant-evaluate `Keyword.spi.defaultText` to a ``SyntaxText`` but I don't
       /// see how that's possible right now.
       private static let keywordTextLookupTable: [SyntaxText] = \(lookupTable)
       """
diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxAnyVisitorFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxAnyVisitorFile.swift
index dcbb9baffef..8be0f3862f0 100644
--- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxAnyVisitorFile.swift
+++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxAnyVisitorFile.swift
@@ -18,7 +18,7 @@ import Utils
 let syntaxAnyVisitorFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
   try! ClassDeclSyntax(
     """
-    /// A `SyntaxVisitor` that can visit the nodes as generic `Syntax` values.
+    /// A `SyntaxVisitor` that can visit the nodes as generic ``Syntax`` values.
     ///
     /// This subclass of `SyntaxVisitor` is slower than the type-specific visitation
     /// of `SyntaxVisitor`. Use `SyntaxAnyVisitor` if the `visitAny(_)` function
diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift
index a7b51661fb2..9ca832fd38e 100644
--- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift
+++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift
@@ -21,8 +21,8 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       """
       // MARK: - \(node.kind.syntaxType)
 
-      /// Protocol to which all `\(node.kind.syntaxType)` nodes conform. Extension point to add
-      /// common methods to all `\(node.kind.syntaxType)` nodes.
+      /// Protocol to which all ``\(node.kind.syntaxType)`` nodes conform. Extension point to add
+      /// common methods to all ``\(node.kind.syntaxType)`` nodes.
       /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
       public protocol \(node.kind.protocolType): \(raw: node.base.protocolType) {}
       """
@@ -62,7 +62,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Create a `\(node.kind.syntaxType)` node from a specialized syntax node.
+        /// Create a ``\(node.kind.syntaxType)`` node from a specialized syntax node.
         public init(_ syntax: some \(node.kind.protocolType)) {
           // We know this cast is going to succeed. Go through init(_: SyntaxData)
           // to do a sanity check and verify the kind matches in debug builds and get
@@ -74,7 +74,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Create a `\(node.kind.syntaxType)` node from a specialized optional syntax node.
+        /// Create a ``\(node.kind.syntaxType)`` node from a specialized optional syntax node.
         public init?(_ syntax: (some \(node.kind.protocolType))?) {
           guard let syntax = syntax else { return nil }
           self.init(syntax)
@@ -95,7 +95,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Create a `\(node.kind.syntaxType)` node from a specialized optional syntax node.
+        /// Create a ``\(node.kind.syntaxType)`` node from a specialized optional syntax node.
         public init?(fromProtocol syntax: \(node.kind.protocolType)?) {
           guard let syntax = syntax else { return nil }
           self.init(fromProtocol: syntax)
@@ -131,8 +131,8 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       try InitializerDeclSyntax(
         """
-        /// Creates a `\(node.kind.syntaxType)` node from the given `SyntaxData`. This assumes
-        /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
+        /// Creates a ``\(node.kind.syntaxType)`` node from the given ``SyntaxData``. This assumes
+        /// that the ``SyntaxData`` is of the correct kind. If it is not, the behaviour
         /// is undefined.
         internal init(_ data: SyntaxData)
         """
diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxCollectionsFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxCollectionsFile.swift
index 1dad9ea35f1..e02dc02f770 100644
--- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxCollectionsFile.swift
+++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxCollectionsFile.swift
@@ -42,8 +42,8 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       !node.documentation.isEmpty
       ? node.documentation
       : """
-      /// `\(node.kind.syntaxType)` represents a collection of one or more
-      /// `\(node.collectionElementType.syntaxBaseName)` nodes. \(node.kind.syntaxType) behaves
+      /// ``\(node.kind.syntaxType)`` represents a collection of one or more
+      /// ``\(node.collectionElementType.syntaxBaseName)`` nodes. ``\(node.kind.syntaxType)`` behaves
       /// as a regular Swift collection, and has accessors that return new
       /// versions of the collection with different children.
       """
@@ -187,12 +187,12 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Creates a new `\(node.kind.syntaxType)` by replacing the underlying layout with
+        /// Creates a new ``\(node.kind.syntaxType)`` by replacing the underlying layout with
         /// a different set of raw syntax nodes.
         ///
         /// - Parameter layout: The new list of raw syntax nodes underlying this
         ///                     collection.
-        /// - Returns: A new `\(node.kind.syntaxType)` with the new layout underlying it.
+        /// - Returns: A new ``\(node.kind.syntaxType)`` with the new layout underlying it.
         internal func replacingLayout(_ layout: [RawSyntax?]) -> \(node.kind.syntaxType) {
           let arena = SyntaxArena()
           let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -204,11 +204,11 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Creates a new `\(node.kind.syntaxType)` by appending the provided syntax element
+        /// Creates a new ``\(node.kind.syntaxType)`` by appending the provided syntax element
         /// to the children.
         ///
         /// - Parameter syntax: The element to append.
-        /// - Returns: A new `\(node.kind.syntaxType)` with that element appended to the end.
+        /// - Returns: A new ``\(node.kind.syntaxType)`` with that element appended to the end.
         public func appending(_ syntax: Element) -> \(node.kind.syntaxType) {
           var newLayout = layoutView.formLayoutArray()
           newLayout.append(syntax.raw)
@@ -219,11 +219,11 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Creates a new `\(node.kind.syntaxType)` by prepending the provided syntax element
+        /// Creates a new ``\(node.kind.syntaxType)`` by prepending the provided syntax element
         /// to the children.
         ///
         /// - Parameter syntax: The element to prepend.
-        /// - Returns: A new `\(node.kind.syntaxType)` with that element prepended to the
+        /// - Returns: A new ``\(node.kind.syntaxType)`` with that element prepended to the
         ///            beginning.
         public func prepending(_ syntax: Element) -> \(node.kind.syntaxType) {
           return inserting(syntax, at: 0)
@@ -233,14 +233,14 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Creates a new `\(node.kind.syntaxType)` by inserting the provided syntax element
+        /// Creates a new ``\(node.kind.syntaxType)`` by inserting the provided syntax element
         /// at the provided index in the children.
         ///
         /// - Parameters:
         ///   - syntax: The element to insert.
         ///   - index: The index at which to insert the element in the collection.
         ///
-        /// - Returns: A new `\(node.kind.syntaxType)` with that element appended to the end.
+        /// - Returns: A new ``\(node.kind.syntaxType)`` with that element appended to the end.
         public func inserting(_ syntax: Element, at index: Int) -> \(node.kind.syntaxType) {
           var newLayout = layoutView.formLayoutArray()
           /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -254,14 +254,14 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Creates a new `\(node.kind.syntaxType)` by replacing the syntax element
+        /// Creates a new ``\(node.kind.syntaxType)`` by replacing the syntax element
         /// at the provided index.
         ///
         /// - Parameters:
         ///   - index: The index at which to replace the element in the collection.
         ///   - syntax: The element to replace with.
         ///
-        /// - Returns: A new `\(node.kind.syntaxType)` with the new element at the provided index.
+        /// - Returns: A new ``\(node.kind.syntaxType)`` with the new element at the provided index.
         public func replacing(childAt index: Int, with syntax: Element) -> \(node.kind.syntaxType) {
           var newLayout = layoutView.formLayoutArray()
           /// Make sure the index is a valid index for replacing
@@ -275,11 +275,11 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Creates a new `\(node.kind.syntaxType)` by removing the syntax element at the
+        /// Creates a new ``\(node.kind.syntaxType)`` by removing the syntax element at the
         /// provided index.
         ///
         /// - Parameter index: The index of the element to remove from the collection.
-        /// - Returns: A new `\(node.kind.syntaxType)` with the element at the provided index
+        /// - Returns: A new ``\(node.kind.syntaxType)`` with the element at the provided index
         ///            removed.
         public func removing(childAt index: Int) -> \(node.kind.syntaxType) {
           var newLayout = layoutView.formLayoutArray()
@@ -291,9 +291,9 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Creates a new `\(node.kind.syntaxType)` by removing the first element.
+        /// Creates a new ``\(node.kind.syntaxType)`` by removing the first element.
         ///
-        /// - Returns: A new `\(node.kind.syntaxType)` with the first element removed.
+        /// - Returns: A new ``\(node.kind.syntaxType)`` with the first element removed.
         public func removingFirst() -> \(node.kind.syntaxType) {
           var newLayout = layoutView.formLayoutArray()
           newLayout.removeFirst()
@@ -304,9 +304,9 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// Creates a new `\(node.kind.syntaxType)` by removing the last element.
+        /// Creates a new ``\(node.kind.syntaxType)`` by removing the last element.
         ///
-        /// - Returns: A new `\(node.kind.syntaxType)` with the last element removed.
+        /// - Returns: A new ``\(node.kind.syntaxType)`` with the last element removed.
         public func removingLast() -> \(node.kind.syntaxType) {
           var newLayout = layoutView.formLayoutArray()
           newLayout.removeLast()
@@ -318,7 +318,7 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
     try! ExtensionDeclSyntax(
       """
-      /// Conformance for `\(node.kind.syntaxType)` to the `BidirectionalCollection` protocol.
+      /// Conformance for ``\(node.kind.syntaxType)`` to the `BidirectionalCollection` protocol.
       extension \(node.kind.syntaxType): BidirectionalCollection
       """
     ) {
diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxNodesFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxNodesFile.swift
index 439353c6509..cfde6a08f59 100644
--- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxNodesFile.swift
+++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxNodesFile.swift
@@ -66,7 +66,7 @@ func syntaxNode(emitKind: SyntaxNodeKind) -> SourceFileSyntax {
 
         DeclSyntax(
           """
-          /// Creates a `\(node.kind.syntaxType)` node from the given `SyntaxData`. This assumes
+          /// Creates a ``\(node.kind.syntaxType)`` node from the given ``SyntaxData``. This assumes
           /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
           /// is undefined.
           internal init(_ data: SyntaxData) {
@@ -192,7 +192,7 @@ func syntaxNode(emitKind: SyntaxNodeKind) -> SourceFileSyntax {
 
             DeclSyntax(
               """
-              /// Adds the provided `\(raw: childElt)` to the node's `\(raw: child.varName)`
+              /// Adds the provided `element` to the node's `\(raw: child.varName)`
               /// collection.
               /// - param element: The new `\(raw: childElt)` to add to the node's
               ///                  `\(raw: child.varName)` collection.
diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxRewriterFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxRewriterFile.swift
index cd9c08b354c..fee64a4c5f7 100644
--- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxRewriterFile.swift
+++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxRewriterFile.swift
@@ -36,7 +36,7 @@ let syntaxRewriterFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       if (node.base == .syntax || node.base == .syntaxCollection) && node.kind != .missing {
         DeclSyntax(
           """
-          /// Visit a `\(node.kind.syntaxType)`.
+          /// Visit a ``\(node.kind.syntaxType)``.
           ///   - Parameter node: the node that is being visited
           ///   - Returns: the rewritten node
           open func visit(_ node: \(node.kind.syntaxType)) -> \(node.kind.syntaxType) {
@@ -47,7 +47,7 @@ let syntaxRewriterFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       } else {
         DeclSyntax(
           """
-          /// Visit a `\(node.kind.syntaxType)`.
+          /// Visit a ``\(node.kind.syntaxType)``.
           ///   - Parameter node: the node that is being visited
           ///   - Returns: the rewritten node
           open func visit(_ node: \(node.kind.syntaxType)) -> \(raw: node.baseType.syntaxBaseName) {
@@ -60,7 +60,7 @@ let syntaxRewriterFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
     DeclSyntax(
       """
-      /// Visit a `TokenSyntax`.
+      /// Visit a ``TokenSyntax``.
       ///   - Parameter node: the node that is being visited
       ///   - Returns: the rewritten node
       open func visit(_ token: TokenSyntax) -> TokenSyntax {
diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxTransformFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxTransformFile.swift
index 97489464f3b..ca4fd296a03 100644
--- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxTransformFile.swift
+++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxTransformFile.swift
@@ -26,7 +26,7 @@ let syntaxTransformFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     for node in SYNTAX_NODES where !node.kind.isBase {
       DeclSyntax(
         """
-        /// Visiting `\(node.kind.syntaxType)` specifically.
+        /// Visiting ``\(node.kind.syntaxType)`` specifically.
         ///   - Parameter node: the node we are visiting.
         ///   - Returns: the sum of whatever the child visitors return.
         func visit(_ node: \(node.kind.syntaxType)) -> ResultType
@@ -47,7 +47,7 @@ let syntaxTransformFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     for node in SYNTAX_NODES where !node.kind.isBase {
       DeclSyntax(
         """
-        /// Visiting `\(node.kind.syntaxType)` specifically.
+        /// Visiting ``\(node.kind.syntaxType)`` specifically.
         ///   - Parameter node: the node we are visiting.
         ///   - Returns: nil by default.
         public func visit(_ node: \(node.kind.syntaxType)) -> ResultType {
diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxVisitorFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxVisitorFile.swift
index 4538ad2bc9f..2a76ef60e89 100644
--- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxVisitorFile.swift
+++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxVisitorFile.swift
@@ -53,7 +53,7 @@ let syntaxVisitorFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     for node in SYNTAX_NODES where !node.kind.isBase {
       DeclSyntax(
         """
-        /// Visiting `\(node.kind.syntaxType)` specifically.
+        /// Visiting ``\(node.kind.syntaxType)`` specifically.
         ///   - Parameter node: the node we are visiting.
         ///   - Returns: how should we continue visiting.
         open func visit(_ node: \(node.kind.syntaxType)) -> SyntaxVisitorContinueKind {
@@ -64,7 +64,7 @@ let syntaxVisitorFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        /// The function called after visiting `\(node.kind.syntaxType)` and its descendents.
+        /// The function called after visiting ``\(node.kind.syntaxType)`` and its descendents.
         ///   - node: the node we just finished visiting.
         open func visitPost(_ node: \(node.kind.syntaxType)) {}
         """
@@ -73,7 +73,7 @@ let syntaxVisitorFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
     DeclSyntax(
       """
-      /// Visiting `TokenSyntax` specifically.
+      /// Visiting ``TokenSyntax`` specifically.
       ///   - Parameter node: the node we are visiting.
       ///   - Returns: how should we continue visiting.
       open func visit(_ token: TokenSyntax) -> SyntaxVisitorContinueKind {
diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TokenKindFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TokenKindFile.swift
index d61f0e4f2c0..5aa0f63e6a9 100644
--- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TokenKindFile.swift
+++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TokenKindFile.swift
@@ -252,7 +252,7 @@ let tokenKindFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
     try! FunctionDeclSyntax(
       """
-      /// Returns the `RawTokenKind` of this `TokenKind` and, if this `TokenKind`
+      /// Returns the ``RawTokenKind`` of this ``TokenKind`` and, if this ``TokenKind``
       /// has associated text, the associated text, otherwise `nil`.
       @_spi(RawSyntax)
       public func decomposeToRaw() -> (rawKind: RawTokenKind, string: String?)
diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TriviaPiecesFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TriviaPiecesFile.swift
index a4c14ce25f0..f88565ba9d0 100644
--- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TriviaPiecesFile.swift
+++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TriviaPiecesFile.swift
@@ -19,7 +19,7 @@ let triviaPiecesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
   try! EnumDeclSyntax(
     """
     /// A contiguous stretch of a single kind of trivia. The constituent part of
-    /// a `Trivia` collection.
+    /// a ``Trivia`` collection.
     ///
     /// For example, four spaces would be represented by
     /// `.spaces(4)`
@@ -173,7 +173,7 @@ let triviaPiecesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     """
     /// Trivia piece for token RawSyntax.
     ///
-    /// In contrast to `TriviaPiece`, a `RawTriviaPiece` does not own the source
+    /// In contrast to ``TriviaPiece``, a ``RawTriviaPiece`` does not own the source
     /// text of a the trivia.
     @_spi(RawSyntax)
     public enum RawTriviaPiece: Equatable
diff --git a/Sources/SwiftBasicFormat/BasicFormat.swift b/Sources/SwiftBasicFormat/BasicFormat.swift
index 1498a2defe8..c9e17847a3a 100644
--- a/Sources/SwiftBasicFormat/BasicFormat.swift
+++ b/Sources/SwiftBasicFormat/BasicFormat.swift
@@ -145,7 +145,7 @@ open class BasicFormat: SyntaxRewriter {
 
   open func requiresNewline(between first: TokenSyntax?, and second: TokenSyntax?) -> Bool {
     // We don't want to add newlines inside string interpolation.
-    // When first or second `TokenSyntax` is a multiline quote we want special handling
+    // When first or second ``TokenSyntax`` is a multiline quote we want special handling
     // even if it's inside a string interpolation, because it still requires newline
     // after open quote and before close quote.
     if let first,
diff --git a/Sources/SwiftCompilerPluginMessageHandling/PluginMacroExpansionContext.swift b/Sources/SwiftCompilerPluginMessageHandling/PluginMacroExpansionContext.swift
index a554fe5a949..e6e76b52fb3 100644
--- a/Sources/SwiftCompilerPluginMessageHandling/PluginMacroExpansionContext.swift
+++ b/Sources/SwiftCompilerPluginMessageHandling/PluginMacroExpansionContext.swift
@@ -62,7 +62,7 @@ class SourceManager {
   /// Syntax added by `add(_:)` method. Keyed by the `id` of the node.
   private var knownSourceSyntax: [Syntax.ID: KnownSourceSyntax] = [:]
 
-  /// Convert syntax information to a `Syntax` node. The location informations
+  /// Convert syntax information to a ``Syntax`` node. The location informations
   /// are cached in the source manager to provide `location(of:)` et al.
   func add(
     _ syntaxInfo: PluginMessage.Syntax,
@@ -120,7 +120,7 @@ class SourceManager {
     )
   }
 
-  /// Get `SourceRange` (file name + UTF-8 offset range) of `node` in the known root nodes.
+  /// Get ``SourceRange`` (file name + UTF-8 offset range) of `node` in the known root nodes.
   /// The root node of `node` must be one of the retured value from `add(_:)`.
   func range(
     of node: Syntax,
@@ -174,7 +174,7 @@ class SourceManager {
 }
 
 fileprivate extension Syntax {
-  /// Get a position in the node by `PositionInSyntaxNode`.
+  /// Get a position in the node by ``PositionInSyntaxNode``.
   func position(at pos: PositionInSyntaxNode) -> AbsolutePosition {
     switch pos {
     case .beforeLeadingTrivia:
diff --git a/Sources/SwiftIDEUtils/Syntax+Classifications.swift b/Sources/SwiftIDEUtils/Syntax+Classifications.swift
index 86352dd9907..2929e620348 100644
--- a/Sources/SwiftIDEUtils/Syntax+Classifications.swift
+++ b/Sources/SwiftIDEUtils/Syntax+Classifications.swift
@@ -14,7 +14,7 @@ import SwiftSyntax
 
 public extension SyntaxProtocol {
 
-  /// Sequence of `SyntaxClassifiedRange`s for this syntax node.
+  /// Sequence of ``SyntaxClassifiedRange``s for this syntax node.
   ///
   /// The provided classified ranges are consecutive and cover the full source
   /// text of the node. The ranges may also span multiple tokens, if multiple
@@ -25,7 +25,7 @@ public extension SyntaxProtocol {
     return SyntaxClassifications(_syntaxNode, in: fullRange)
   }
 
-  /// Sequence of `SyntaxClassifiedRange`s contained in this syntax node within
+  /// Sequence of ``SyntaxClassifiedRange``s contained in this syntax node within
   /// a relative range.
   ///
   /// The provided classified ranges may extend beyond the provided `range`.
@@ -37,16 +37,16 @@ public extension SyntaxProtocol {
   /// intersect the provided `range`.
   ///
   /// - Parameters:
-  ///   - in: The relative byte range to pull `SyntaxClassifiedRange`s from.
-  /// - Returns: Sequence of `SyntaxClassifiedRange`s.
+  ///   - in: The relative byte range to pull ``SyntaxClassifiedRange``s from.
+  /// - Returns: Sequence of ``SyntaxClassifiedRange``s.
   func classifications(in range: ByteSourceRange) -> SyntaxClassifications {
     return SyntaxClassifications(_syntaxNode, in: range)
   }
 
-  /// The `SyntaxClassifiedRange` for a relative byte offset.
+  /// The ``SyntaxClassifiedRange`` for a relative byte offset.
   /// - Parameters:
   ///   - at: The relative to the node byte offset.
-  /// - Returns: The `SyntaxClassifiedRange` for the offset or nil if the source text
+  /// - Returns: The ``SyntaxClassifiedRange`` for the offset or nil if the source text
   ///   at the given offset is unclassified.
   func classification(at offset: Int) -> SyntaxClassifiedRange? {
     let classifications = SyntaxClassifications(_syntaxNode, in: ByteSourceRange(offset: offset, length: 1))
@@ -54,10 +54,10 @@ public extension SyntaxProtocol {
     return iterator.next()
   }
 
-  /// The `SyntaxClassifiedRange` for an absolute position.
+  /// The ``SyntaxClassifiedRange`` for an absolute position.
   /// - Parameters:
   ///   - at: The absolute position.
-  /// - Returns: The `SyntaxClassifiedRange` for the position or nil if the source text
+  /// - Returns: The ``SyntaxClassifiedRange`` for the position or nil if the source text
   ///   at the given position is unclassified.
   func classification(at position: AbsolutePosition) -> SyntaxClassifiedRange? {
     let relativeOffset = position.utf8Offset - self.position.utf8Offset
diff --git a/Sources/SwiftIDEUtils/SyntaxClassifier.swift b/Sources/SwiftIDEUtils/SyntaxClassifier.swift
index 7fba69d10f9..9ea2faba815 100644
--- a/Sources/SwiftIDEUtils/SyntaxClassifier.swift
+++ b/Sources/SwiftIDEUtils/SyntaxClassifier.swift
@@ -26,7 +26,7 @@ fileprivate extension SyntaxProtocol {
 }
 
 extension TokenSyntax {
-  /// The `SyntaxClassifiedRange` for the token text, excluding trivia.
+  /// The ``SyntaxClassifiedRange`` for the token text, excluding trivia.
   public var tokenClassification: SyntaxClassifiedRange {
     let contextualClassification = self.contextualClassification
     let relativeOffset = leadingTriviaLength.utf8Length
@@ -122,7 +122,7 @@ private struct ClassificationVisitor {
     self.targetRange = range
     self.classifications = []
 
-    // `withExtendedLifetime` to make sure `SyntaxArena` for the node alive
+    // `withExtendedLifetime` to make sure ``SyntaxArena`` for the node alive
     // during the visit.
     withExtendedLifetime(node) {
       _ = self.visit(
@@ -235,7 +235,7 @@ private struct ClassificationVisitor {
   }
 }
 
-/// Provides a sequence of `SyntaxClassifiedRange`s for a syntax node.
+/// Provides a sequence of ``SyntaxClassifiedRange``s for a syntax node.
 public struct SyntaxClassifications: Sequence {
   public typealias Iterator = Array<SyntaxClassifiedRange>.Iterator
 
diff --git a/Sources/SwiftParser/Directives.swift b/Sources/SwiftParser/Directives.swift
index ee13f930933..7829aa9ff22 100644
--- a/Sources/SwiftParser/Directives.swift
+++ b/Sources/SwiftParser/Directives.swift
@@ -42,7 +42,7 @@ extension Parser {
   /// declarations, and expressions. It is generic over the particular kind of
   /// parse that must occur for these elements, and allows a context-specific
   /// syntax kind to be emitted to collect the results. For example, declaration
-  /// parsing parses items and collects the items into a `MemberDeclListSyntax`
+  /// parsing parses items and collects the items into a ``MemberDeclListSyntax``
   /// node.
   ///
   /// Grammar
diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift
index 0174bb5cde7..889317662d5 100644
--- a/Sources/SwiftParser/Expressions.swift
+++ b/Sources/SwiftParser/Expressions.swift
@@ -2337,7 +2337,7 @@ extension Parser {
     let (unexpectedBeforeSwitchKeyword, switchKeyword) = self.eat(switchHandle)
 
     // If there is no expression, like `switch { default: return false }` then left brace would parsed as
-    // a `RawClosureExprSyntax` in the condition, which is most likely not what the user meant.
+    // a ``RawClosureExprSyntax`` in the condition, which is most likely not what the user meant.
     // Create a missing condition instead and use the `{` for the start of the body.
     let subject: RawExprSyntax
     if self.at(.leftBrace) {
diff --git a/Sources/SwiftParser/Lexer/LexemeSequence.swift b/Sources/SwiftParser/Lexer/LexemeSequence.swift
index 9a4eb1a47e8..18b74568c3a 100644
--- a/Sources/SwiftParser/Lexer/LexemeSequence.swift
+++ b/Sources/SwiftParser/Lexer/LexemeSequence.swift
@@ -26,7 +26,7 @@ extension Lexer {
     /// retain/release cost of an array.
     ///
     /// The states will be freed when the lexer is finished, i.e. when this
-    /// `LexemeSequence` is deallocated.
+    /// ``LexemeSequence`` is deallocated.
     ///
     /// The memory footpring of not freeing past lexer states is neglible. It's
     /// usually less than 0.1% of the memory allocated by the syntax arena.
@@ -87,7 +87,7 @@ extension Lexer {
     }
 
     #if SWIFTPARSER_ENABLE_ALTERNATE_TOKEN_INTROSPECTION
-    /// If `pointer` is in the source buffer of this `LexemeSequence`, return
+    /// If `pointer` is in the source buffer of this ``LexemeSequence``, return
     /// its offset, otherwise `nil`. Should only be used for the parser's
     /// alternate token introspection
     func offset(of pointer: UnsafePointer<UInt8>) -> Int? {
diff --git a/Sources/SwiftParser/Names.swift b/Sources/SwiftParser/Names.swift
index 9daeff401ad..f1bb63824c7 100644
--- a/Sources/SwiftParser/Names.swift
+++ b/Sources/SwiftParser/Names.swift
@@ -284,8 +284,8 @@ extension Lexer.Lexeme {
   }
 
   var isLexerClassifiedKeyword: Bool {
-    // Only lexer-classified lexemes have `RawTokenKind` of `keyword.
-    // Contextual keywords will only be made keywords when a `RawTokenSyntax` is
+    // Only lexer-classified lexemes have ``RawTokenKind`` of `keyword.
+    // Contextual keywords will only be made keywords when a ``RawTokenSyntax`` is
     // constructed from them.
     return self.rawTokenKind == .keyword
   }
diff --git a/Sources/SwiftParser/Parser.swift b/Sources/SwiftParser/Parser.swift
index 5398227bbe4..80fdc8d51d7 100644
--- a/Sources/SwiftParser/Parser.swift
+++ b/Sources/SwiftParser/Parser.swift
@@ -14,7 +14,7 @@
 
 /// A parser for the Swift programming language.
 ///
-/// `Parser` implements a recursive descent parser that produces a SwiftSyntax
+/// ``Parser`` implements a recursive descent parser that produces a SwiftSyntax
 /// tree. Its implementation is divided among a set of files named for the
 /// class of syntax nodes they parse. For example, declaration parsing happens
 /// in `Declaration.swift`, and expression parsing happens in `Expression.swift`.
@@ -110,7 +110,7 @@ public struct Parser {
   static let defaultMaximumNestingLevel = 256
   #endif
 
-  /// Initializes a `Parser` from the given string.
+  /// Initializes a ``Parser`` from the given string.
   public init(_ input: String, maximumNestingLevel: Int? = nil) {
     self.maximumNestingLevel = maximumNestingLevel ?? Self.defaultMaximumNestingLevel
 
@@ -128,7 +128,7 @@ public struct Parser {
     self.currentToken = self.lexemes.advance()
   }
 
-  /// Initializes a `Parser` from the given input buffer.
+  /// Initializes a ``Parser`` from the given input buffer.
   ///
   /// - Parameters
   ///   - input: An input buffer containing Swift source text.
@@ -212,7 +212,7 @@ public struct Parser {
 
   /// When compiled with `SWIFTPARSER_ENABLE_ALTERNATE_TOKEN_INTROSPECTION`, and
   /// `shouldRecordAlternativeTokenChoices` is `true` the parser records which
-  /// `TokenSpec`s it checked for a token at a specific offset in the source
+  /// ``TokenSpec``s it checked for a token at a specific offset in the source
   /// file. The offsets are the location of the token text's start (excluding
   /// leading trivia).
   ///
@@ -246,12 +246,12 @@ extension Parser {
 extension Parser: TokenConsumer {}
 
 extension Parser {
-  /// Consumes the current token and sets its kind to the given `TokenKind`,
+  /// Consumes the current token and sets its kind to the given ``TokenKind``,
   /// then advances the lexer to the next token.
   ///
   /// - Parameter kind: The kind to reset the consumed token to.
   /// - Returns: The token that was consumed with its kind re-mapped to the
-  ///            given `TokenKind`.
+  ///            given ``TokenKind``.
   mutating func consumeAnyToken(remapping kind: RawTokenKind) -> RawTokenSyntax {
     self.currentToken.rawTokenKind = kind
     return self.consumeAnyToken()
diff --git a/Sources/SwiftParser/Specifiers.swift b/Sources/SwiftParser/Specifiers.swift
index 0f966d22f2e..ede761ba708 100644
--- a/Sources/SwiftParser/Specifiers.swift
+++ b/Sources/SwiftParser/Specifiers.swift
@@ -136,19 +136,19 @@ public enum EffectSpecifier: TokenSpecSet {
 /// Specify the effect specifiers trait manually as a one off.
 protocol RawEffectSpecifiersTrait {
   /// The token kinds that should be consumed as misspelled `asyncSpecifier`.
-  /// Should be a subset of `AsyncEffectSpecifier`.
+  /// Should be a subset of ``AsyncEffectSpecifier``.
   associatedtype MisspelledAsyncSpecifiers: TokenSpecSet
 
   /// The token kinds that we can consume as a correct `asyncSpecifier`.
-  /// Should be a subset of `AsyncEffectSpecifier`.
+  /// Should be a subset of ``AsyncEffectSpecifier``.
   associatedtype CorrectAsyncTokenKinds: TokenSpecSet
 
   /// The token kinds that should be consumed as misspelled `throwsSpecifier`.
-  /// Should be a subset of `ThrowsEffectSpecifier`.
+  /// Should be a subset of ``ThrowsEffectSpecifier``.
   associatedtype MisspelledThrowsTokenKinds: TokenSpecSet
 
   /// The token kinds that we can consume as a correct `throwsSpecifier`.
-  /// Should be a subset of `ThrowsEffectSpecifier`.
+  /// Should be a subset of ``ThrowsEffectSpecifier``.
   associatedtype CorrectThrowsTokenKinds: TokenSpecSet
 
   var unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? { get }
diff --git a/Sources/SwiftParser/SyntaxUtils.swift b/Sources/SwiftParser/SyntaxUtils.swift
index 93841d566b4..2ffcf97aec5 100644
--- a/Sources/SwiftParser/SyntaxUtils.swift
+++ b/Sources/SwiftParser/SyntaxUtils.swift
@@ -26,7 +26,7 @@ extension RawUnexpectedNodesSyntax {
     })
   }
 
-  /// If `nodes` is not empty, construct a `RawUnexpectedNodesSyntax`
+  /// If `nodes` is not empty, construct a ``RawUnexpectedNodesSyntax``
   /// containing those tokens, otherwise return `nil`.
   init?<SyntaxType: RawSyntaxNodeProtocol>(_ nodes: [SyntaxType], arena: __shared SyntaxArena) {
     if nodes.isEmpty {
@@ -36,7 +36,7 @@ extension RawUnexpectedNodesSyntax {
     }
   }
 
-  /// If `nodes` contains non-`nil` values, construct a `RawUnexpectedNodesSyntax`
+  /// If `nodes` contains non-`nil` values, construct a ``RawUnexpectedNodesSyntax``
   /// containing those tokens, otherwise return `nil`.
   init?<SyntaxType: RawSyntaxNodeProtocol>(_ nodes: [SyntaxType?], arena: __shared SyntaxArena) {
     self.init(nodes.compactMap({ $0 }), arena: arena)
diff --git a/Sources/SwiftParser/TokenConsumer.swift b/Sources/SwiftParser/TokenConsumer.swift
index b7c8bb5d2a6..c7448e5be9f 100644
--- a/Sources/SwiftParser/TokenConsumer.swift
+++ b/Sources/SwiftParser/TokenConsumer.swift
@@ -12,7 +12,7 @@
 
 @_spi(RawSyntax) import SwiftSyntax
 
-/// A type that consumes  instances of `TokenSyntax`.
+/// A type that consumes  instances of ``TokenSyntax``.
 protocol TokenConsumer {
   associatedtype Token
   /// The current token syntax being examined by the consumer
diff --git a/Sources/SwiftParser/TokenSpec.swift b/Sources/SwiftParser/TokenSpec.swift
index 88780f35ef4..695c24df42e 100644
--- a/Sources/SwiftParser/TokenSpec.swift
+++ b/Sources/SwiftParser/TokenSpec.swift
@@ -14,7 +14,7 @@
 
 /// Pre-computes the keyword a lexeme might represent. This makes matching
 /// a lexeme that has been converted into `PrepareForKeyword` match cheaper to
-/// match against multiple `TokenSpec` that assume a keyword.
+/// match against multiple ``TokenSpec`` that assume a keyword.
 struct PrepareForKeywordMatch {
   /// The kind of the lexeme.
   fileprivate let rawTokenKind: RawTokenKind
@@ -40,14 +40,14 @@ struct PrepareForKeywordMatch {
 
 /// Describes a token that should be consumed by the parser.
 ///
-/// All the methods in here and all functions that take a `TokenSpec` need to be
-/// marked `@inline(__always)` so the compiler inlines the `RawTokenKind` we are
+/// All the methods in here and all functions that take a ``TokenSpec`` need to be
+/// marked `@inline(__always)` so the compiler inlines the ``RawTokenKind`` we are
 /// matching against and is thus able to rule out one of the branches in
 /// `matches(rawTokenKind:text:)` based on the matched kind.
 @_spi(AlternateTokenIntrospection)
 public struct TokenSpec {
   /// The kind we expect the token that we want to consume to have.
-  /// This can be a keyword, in which case the `TokenSpec` will also match an
+  /// This can be a keyword, in which case the ``TokenSpec`` will also match an
   /// identifier with the same text as the keyword and remap it to that keyword
   /// when consumed.
   ///
@@ -162,8 +162,8 @@ public struct TokenSpec {
     )
   }
 
-  /// Returns a `TokenKind` that will most likely be parsed as a token that
-  /// matches this `TokenSpec`.
+  /// Returns a ``TokenKind`` that will most likely be parsed as a token that
+  /// matches this ``TokenSpec``.
   ///
   /// IMPORTANT: Should only be used when generating tokens during the
   /// modification of test cases. This should never be used in the parser itself.
diff --git a/Sources/SwiftParserDiagnostics/LexerDiagnosticMessages.swift b/Sources/SwiftParserDiagnostics/LexerDiagnosticMessages.swift
index 44fcbe84d69..35da8cb1445 100644
--- a/Sources/SwiftParserDiagnostics/LexerDiagnosticMessages.swift
+++ b/Sources/SwiftParserDiagnostics/LexerDiagnosticMessages.swift
@@ -129,7 +129,7 @@ public struct InvalidDigitInIntegerLiteral: TokenError {
 // MARK: - Convert TokenDiagnostic from SwiftSyntax to error messages
 
 public extension SwiftSyntax.TokenDiagnostic {
-  /// `tokenText` is the entire text of the token in which the `TokenDiagnostic`
+  /// `tokenText` is the entire text of the token in which the ``TokenDiagnostic``
   /// occurred, including trivia.
   @_spi(RawSyntax)
   func diagnosticMessage(wholeTextBytes: [UInt8]) -> DiagnosticMessage {
diff --git a/Sources/SwiftParserDiagnostics/SyntaxExtensions.swift b/Sources/SwiftParserDiagnostics/SyntaxExtensions.swift
index 2ab22d5a986..050cfb3451e 100644
--- a/Sources/SwiftParserDiagnostics/SyntaxExtensions.swift
+++ b/Sources/SwiftParserDiagnostics/SyntaxExtensions.swift
@@ -73,7 +73,7 @@ extension Syntax {
 
 extension SyntaxProtocol {
   /// A name that can be used to describe this node's type in diagnostics or `nil` if there is no good name for this node.
-  /// If `allowBlockNames` is `false`, `CodeBlockSyntax` and `MemberDeclBlockSyntax` are not considered to have a good name and will return `nil`.
+  /// If `allowBlockNames` is `false`, ``CodeBlockSyntax`` and ``MemberDeclBlockSyntax`` are not considered to have a good name and will return `nil`.
   func nodeTypeNameForDiagnostics(allowBlockNames: Bool) -> String? {
     let syntax = Syntax(self)
     if !allowBlockNames && (syntax.is(CodeBlockSyntax.self) || syntax.is(MemberDeclBlockSyntax.self)) {
diff --git a/Sources/SwiftSyntax/BumpPtrAllocator.swift b/Sources/SwiftSyntax/BumpPtrAllocator.swift
index 8843e97e0fd..dd237305f51 100644
--- a/Sources/SwiftSyntax/BumpPtrAllocator.swift
+++ b/Sources/SwiftSyntax/BumpPtrAllocator.swift
@@ -135,7 +135,7 @@ public class BumpPtrAllocator {
   ///
   /// The returned buffer is bound to the type, but not initialized.
   /// Clients should never call `deallocate()` on the returned buffer.
-  /// In general, using `BumpPtrAllocator` for placing non-trivial values (e.g.
+  /// In general, using ``BumpPtrAllocator`` for placing non-trivial values (e.g.
   /// class instances, existentials, etc.) is strongly discouraged because they
   /// are not automatically deinitialized.
   public func allocate<T>(_: T.Type, count: Int) -> UnsafeMutableBufferPointer<T> {
diff --git a/Sources/SwiftSyntax/IncrementalParseTransition.swift b/Sources/SwiftSyntax/IncrementalParseTransition.swift
index a967a0294bc..6fa9f60fc97 100644
--- a/Sources/SwiftSyntax/IncrementalParseTransition.swift
+++ b/Sources/SwiftSyntax/IncrementalParseTransition.swift
@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-/// Accepts the re-used `Syntax` nodes that `IncrementalParseTransition`
+/// Accepts the re-used ``Syntax`` nodes that `IncrementalParseTransition`
 /// determined they should be re-used for a parse invocation.
 ///
 /// The client can use this information to potentially avoid unnecessary work
@@ -19,7 +19,7 @@
 /// This is also used for testing purposes to ensure incremental reparsing
 /// worked as expected.
 public protocol IncrementalParseReusedNodeDelegate {
-  /// Accepts the range and `Syntax` node of skipped source region.
+  /// Accepts the range and ``Syntax`` node of skipped source region.
   ///
   /// - Parameters:
   ///   - range: The source region of the currently parsed source.
@@ -206,7 +206,7 @@ public struct IncrementalParseLookup {
   fileprivate let transition: IncrementalParseTransition
   fileprivate var cursor: SyntaxCursor
 
-  /// Create a new `IncrementalParseLookup` that can look nodes up based on the
+  /// Create a new ``IncrementalParseLookup`` that can look nodes up based on the
   /// given ``IncrementalParseTransition``.
   public init(transition: IncrementalParseTransition) {
     self.transition = transition
@@ -222,15 +222,15 @@ public struct IncrementalParseLookup {
   }
 
   /// Does a lookup to see if the current source `offset` should be associated
-  /// with a known `Syntax` node and its region skipped during parsing.
+  /// with a known ``Syntax`` node and its region skipped during parsing.
   ///
   /// The implementation is responsible for checking whether an incremental edit
-  /// has invalidated the previous `Syntax` node.
+  /// has invalidated the previous ``Syntax`` node.
   ///
   /// - Parameters:
   ///   - offset: The byte offset of the source string that is currently parsed.
   ///   - kind: The `CSyntaxKind` that the parser expects at this position.
-  /// - Returns: A `Syntax` node from the previous parse invocation,
+  /// - Returns: A ``Syntax`` node from the previous parse invocation,
   ///            representing the contents of this region, if it is still valid
   ///            to re-use. `nil` otherwise.
   @_spi(RawSyntax)
diff --git a/Sources/SwiftSyntax/Raw/RawSyntax.swift b/Sources/SwiftSyntax/Raw/RawSyntax.swift
index f8be702e513..6d3c9206546 100644
--- a/Sources/SwiftSyntax/Raw/RawSyntax.swift
+++ b/Sources/SwiftSyntax/Raw/RawSyntax.swift
@@ -26,10 +26,10 @@ struct RecursiveRawSyntaxFlags: OptionSet {
   /// Whether the tree contained by this layout has any
   ///  - missing nodes or
   ///  - unexpected nodes or
-  ///  - tokens with a `TokenDiagnostic` of severity `error`
+  ///  - tokens with a ``TokenDiagnostic`` of severity `error`
   static let hasError = RecursiveRawSyntaxFlags(rawValue: 1 << 0)
   /// Whether the tree contained by this layout has any tokens with a
-  /// `TokenDiagnostic` of severity `warning`.
+  /// ``TokenDiagnostic`` of severity `warning`.
   static let hasWarning = RecursiveRawSyntaxFlags(rawValue: 1 << 1)
   static let hasSequenceExpr = RecursiveRawSyntaxFlags(rawValue: 1 << 2)
   static let hasMaximumNestingLevelOverflow = RecursiveRawSyntaxFlags(rawValue: 1 << 3)
@@ -61,7 +61,7 @@ internal struct RawSyntaxData {
 
     var presence: SourcePresence
 
-    /// Store the members of `TokenDiagnostic` individually so the compiler can pack
+    /// Store the members of ``TokenDiagnostic`` individually so the compiler can pack
     /// `ParsedToken` more efficiently (saving 2 bytes)
     /// `tokenDiagnosticByteOffset` is ignored if `tokenDiagnosticKind` is `nil`
     private var tokenDiagnosticKind: TokenDiagnostic.Kind?
@@ -104,7 +104,7 @@ internal struct RawSyntaxData {
     var numLeadingTrivia: UInt32
     var byteLength: UInt32
     var presence: SourcePresence
-    /// Store the members of `TokenDiagnostic` individually so the compiler can pack
+    /// Store the members of ``TokenDiagnostic`` individually so the compiler can pack
     /// `ParsedToken` more efficiently (saving 2 bytes)
     /// `tokenDiagnosticByteOffset` is ignored if `tokenDiagnosticKind` is `nil`
     private var tokenDiagnosticKind: TokenDiagnostic.Kind?
@@ -383,7 +383,7 @@ extension RawSyntax {
   /// Unlike `description`, this provides a source-accurate representation
   /// even in the presence of malformed UTF-8 in the input source.
   ///
-  /// The `SyntaxText` arguments passed to the visitor are only guaranteed
+  /// The ``SyntaxText`` arguments passed to the visitor are only guaranteed
   /// to be valid within that call. It is unsafe to escape the `SyntaxValue`
   /// values outside of the closure.
   public func withEachSyntaxText(body: (SyntaxText) throws -> Void) rethrows {
diff --git a/Sources/SwiftSyntax/Raw/RawSyntaxLayoutView.swift b/Sources/SwiftSyntax/Raw/RawSyntaxLayoutView.swift
index 55faea63f5c..66e9c8a8054 100644
--- a/Sources/SwiftSyntax/Raw/RawSyntaxLayoutView.swift
+++ b/Sources/SwiftSyntax/Raw/RawSyntaxLayoutView.swift
@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 extension RawSyntax {
-  /// A view into the `RawSyntax` that exposes functionality that's specific to layout nodes.
+  /// A view into the ``RawSyntax`` that exposes functionality that's specific to layout nodes.
   /// The token's payload must be a layout, otherwise this traps.
   @_spi(RawSyntax)
   public var layoutView: RawSyntaxLayoutView? {
@@ -24,7 +24,7 @@ extension RawSyntax {
   }
 }
 
-/// A view into `RawSyntax` that exposes functionality that only applies to layout nodes.
+/// A view into ``RawSyntax`` that exposes functionality that only applies to layout nodes.
 @_spi(RawSyntax)
 public struct RawSyntaxLayoutView {
   private let raw: RawSyntax
diff --git a/Sources/SwiftSyntax/Raw/RawSyntaxNodeProtocol.swift b/Sources/SwiftSyntax/Raw/RawSyntaxNodeProtocol.swift
index a358d9103c1..d3ca583edaa 100644
--- a/Sources/SwiftSyntax/Raw/RawSyntaxNodeProtocol.swift
+++ b/Sources/SwiftSyntax/Raw/RawSyntaxNodeProtocol.swift
@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 /// All typed raw syntax nodes conform to this protocol.
-/// `RawXXXSyntax` is a typed wrappeer of `RawSyntax`.
+/// `RawXXXSyntax` is a typed wrappeer of ``RawSyntax``.
 @_spi(RawSyntax)
 public protocol RawSyntaxNodeProtocol: CustomStringConvertible, TextOutputStreamable {
   /// Returns `true` if `raw` can be cast to this concrete raw syntax type.
@@ -50,13 +50,13 @@ public extension RawSyntaxNodeProtocol {
   /// Whether the tree contained by this layout has any
   ///  - missing nodes or
   ///  - unexpected nodes or
-  ///  - tokens with a `TokenDiagnostic` of severity `error`
+  ///  - tokens with a ``TokenDiagnostic`` of severity `error`
   var hasError: Bool {
     return raw.recursiveFlags.contains(.hasError)
   }
 }
 
-/// `RawSyntax` itself conforms to `RawSyntaxNodeProtocol`.
+/// ``RawSyntax`` itself conforms to `RawSyntaxNodeProtocol`.
 extension RawSyntax: RawSyntaxNodeProtocol {
   @_spi(RawSyntax)
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
@@ -171,7 +171,7 @@ public struct RawTokenSyntax: RawSyntaxNodeProtocol {
     tokenView.trailingRawTriviaPieces
   }
 
-  /// Creates a `RawTokenSyntax`. `wholeText` must be managed by the same
+  /// Creates a ``RawTokenSyntax``. `wholeText` must be managed by the same
   /// `arena`. `textRange` is a range of the token text in `wholeText`.
   public init(
     kind: RawTokenKind,
@@ -192,7 +192,7 @@ public struct RawTokenSyntax: RawSyntaxNodeProtocol {
     self = RawTokenSyntax(unchecked: raw)
   }
 
-  /// Creates a `RawTokenSyntax`. `text` and trivia must be managed by the same
+  /// Creates a ``RawTokenSyntax``. `text` and trivia must be managed by the same
   /// `arena`.
   public init(
     kind: RawTokenKind,
@@ -255,7 +255,7 @@ public struct RawTokenSyntax: RawSyntaxNodeProtocol {
     self = RawTokenSyntax(unchecked: raw)
   }
 
-  /// Creates a missing `TokenSyntax` with the specified kind.
+  /// Creates a missing ``TokenSyntax`` with the specified kind.
   /// If `text` is passed, it will be used to represent the missing token's text.
   /// If `text` is `nil`, the `kind`'s default text will be used.
   /// If that is also `nil`, the token will have empty text.
diff --git a/Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift b/Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift
index d1ad19f9a01..fb480275f45 100644
--- a/Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift
+++ b/Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift
@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 extension RawSyntax {
-  /// A view into the `RawSyntax` that exposes functionality that's specific to tokens.
+  /// A view into the ``RawSyntax`` that exposes functionality that's specific to tokens.
   /// The token's payload must be a token, otherwise this traps.
   @_spi(RawSyntax)
   public var tokenView: RawSyntaxTokenView? {
@@ -24,7 +24,7 @@ extension RawSyntax {
   }
 }
 
-/// A view into `RawSyntax` that exposes functionality that only applies to tokens.
+/// A view into ``RawSyntax`` that exposes functionality that only applies to tokens.
 @_spi(RawSyntax)
 public struct RawSyntaxTokenView {
   let raw: RawSyntax
@@ -117,13 +117,13 @@ public struct RawSyntaxTokenView {
     }
   }
 
-  /// Returns the leading `Trivia` length.
+  /// Returns the leading ``Trivia`` length.
   @_spi(RawSyntax)
   public var leadingTriviaLength: SourceLength {
     return SourceLength(utf8Length: leadingTriviaByteLength)
   }
 
-  /// Returns the trailing `Trivia` length.
+  /// Returns the trailing ``Trivia`` length.
   @_spi(RawSyntax)
   public var trailingTriviaLength: SourceLength {
     return SourceLength(utf8Length: trailingTriviaByteLength)
@@ -157,20 +157,20 @@ public struct RawSyntaxTokenView {
     }
   }
 
-  /// Returns the leading `Trivia`.
+  /// Returns the leading ``Trivia``.
   @_spi(RawSyntax)
   public func formLeadingTrivia() -> Trivia {
     return Trivia(pieces: leadingRawTriviaPieces.map({ TriviaPiece(raw: $0) }))
   }
 
-  /// Returns the trailing `Trivia`.
+  /// Returns the trailing ``Trivia``.
   /// - Returns: nil if called on a layout node.
   @_spi(RawSyntax)
   public func formTrailingTrivia() -> Trivia {
     return Trivia(pieces: trailingRawTriviaPieces.map({ TriviaPiece(raw: $0) }))
   }
 
-  /// Returns a `RawSyntax` node with the same source text but with the token
+  /// Returns a ``RawSyntax`` node with the same source text but with the token
   /// kind changed to `newValue`.
   @_spi(RawSyntax)
   public func withKind(_ newValue: TokenKind, arena: SyntaxArena) -> RawSyntax {
@@ -198,7 +198,7 @@ public struct RawSyntaxTokenView {
     }
   }
 
-  /// Returns a `RawSyntax` node with the presence changed to `newValue`.
+  /// Returns a ``RawSyntax`` node with the presence changed to `newValue`.
   @_spi(RawSyntax)
   public func withPresence(_ newValue: SourcePresence, arena: SyntaxArena) -> RawSyntax {
     arena.addChild(self.raw.arenaReference)
diff --git a/Sources/SwiftSyntax/SourceLocation.swift b/Sources/SwiftSyntax/SourceLocation.swift
index 84243324423..3dd1ace3943 100644
--- a/Sources/SwiftSyntax/SourceLocation.swift
+++ b/Sources/SwiftSyntax/SourceLocation.swift
@@ -83,8 +83,8 @@ public struct SourceRange: Hashable, Codable, CustomDebugStringConvertible {
   }
 }
 
-/// Converts `AbsolutePosition`s of syntax nodes to `SourceLocation`s, and
-/// vice-versa. The `AbsolutePosition`s must be originating from nodes that are
+/// Converts ``AbsolutePosition``s of syntax nodes to ``SourceLocation``s, and
+/// vice-versa. The ``AbsolutePosition``s must be originating from nodes that are
 /// part of the same tree that was used to initialize this class.
 public final class SourceLocationConverter {
   let file: String
@@ -145,8 +145,8 @@ public final class SourceLocationConverter {
     }
   }
 
-  /// Convert a `AbsolutePosition` to a `SourceLocation`. If the position is
-  /// exceeding the file length then the `SourceLocation` for the end of file
+  /// Convert a ``AbsolutePosition`` to a ``SourceLocation``. If the position is
+  /// exceeding the file length then the ``SourceLocation`` for the end of file
   /// is returned. If position is negative the location for start of file is
   /// returned.
   public func location(for origpos: AbsolutePosition) -> SourceLocation {
@@ -190,7 +190,7 @@ public final class SourceLocationConverter {
     )
   }
 
-  /// Convert a line/column to a `SourceLocation`. If the line/column exceeds
+  /// Convert a line/column to a ``SourceLocation``. If the line/column exceeds
   /// the boundaries of the file or the line, the position returned is one
   /// adjusted to the closest boundary (beginning/end of file or line).
   ///
@@ -389,9 +389,9 @@ fileprivate func computeLines(_ source: SyntaxText) -> ([AbsolutePosition], Abso
 }
 
 fileprivate extension SyntaxText {
-  /// Walks and passes to `body` the `SourceLength` for every detected line,
+  /// Walks and passes to `body` the ``SourceLength`` for every detected line,
   /// with the newline character included.
-  /// - Returns: The leftover `SourceLength` at the end of the walk.
+  /// - Returns: The leftover ``SourceLength`` at the end of the walk.
   func forEachLineLength(
     prefix: SourceLength = .zero,
     body: (SourceLength) -> ()
@@ -436,9 +436,9 @@ fileprivate extension SyntaxText {
 }
 
 fileprivate extension RawTriviaPiece {
-  /// Walks and passes to `body` the `SourceLength` for every detected line,
+  /// Walks and passes to `body` the ``SourceLength`` for every detected line,
   /// with the newline character included.
-  /// - Returns: The leftover `SourceLength` at the end of the walk.
+  /// - Returns: The leftover ``SourceLength`` at the end of the walk.
   func forEachLineLength(
     prefix: SourceLength = .zero,
     body: (SourceLength) -> ()
@@ -483,9 +483,9 @@ fileprivate extension RawTriviaPiece {
 }
 
 fileprivate extension Array where Element == RawTriviaPiece {
-  /// Walks and passes to `body` the `SourceLength` for every detected line,
+  /// Walks and passes to `body` the ``SourceLength`` for every detected line,
   /// with the newline character included.
-  /// - Returns: The leftover `SourceLength` at the end of the walk.
+  /// - Returns: The leftover ``SourceLength`` at the end of the walk.
   func forEachLineLength(
     prefix: SourceLength = .zero,
     body: (SourceLength) -> ()
@@ -499,9 +499,9 @@ fileprivate extension Array where Element == RawTriviaPiece {
 }
 
 fileprivate extension TokenSyntax {
-  /// Walks and passes to `body` the `SourceLength` for every detected line,
+  /// Walks and passes to `body` the ``SourceLength`` for every detected line,
   /// with the newline character included.
-  /// - Returns: The leftover `SourceLength` at the end of the walk.
+  /// - Returns: The leftover ``SourceLength`` at the end of the walk.
   func forEachLineLength(
     prefix: SourceLength = .zero,
     body: (SourceLength) -> ()
diff --git a/Sources/SwiftSyntax/Syntax.swift b/Sources/SwiftSyntax/Syntax.swift
index 6a539a2e525..4c4b3325ed4 100644
--- a/Sources/SwiftSyntax/Syntax.swift
+++ b/Sources/SwiftSyntax/Syntax.swift
@@ -78,7 +78,7 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
     self = syntax._syntaxNode
   }
 
-  /// Creates a new `Syntax` node from any node that conforms to ``SyntaxProtocol``.
+  /// Creates a new ``Syntax`` node from any node that conforms to ``SyntaxProtocol``.
   public init(fromProtocol syntax: SyntaxProtocol) {
     self = syntax._syntaxNode
   }
@@ -118,7 +118,7 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
 }
 
 extension Syntax: Identifiable {
-  /// `SyntaxIdentifier` uniquely identifies a node.
+  /// ``SyntaxIdentifier`` uniquely identifies a node.
   public typealias ID = SyntaxIdentifier
 }
 
@@ -129,7 +129,7 @@ extension Syntax {
   /// Unlike `description`, this provides a source-accurate representation
   /// even in the presence of malformed UTF-8 in the input source.
   ///
-  /// The `SyntaxText` arguments passed to the visitor are only guaranteed
+  /// The ``SyntaxText`` arguments passed to the visitor are only guaranteed
   /// to be valid within that call. It is unsafe to escape the `SyntaxValue`
   /// values outside of the closure.
   @_spi(RawSyntax)
@@ -239,7 +239,7 @@ extension SyntaxProtocol {
 
   /// The dynamic metatype of the concrete node. You almost always want to prefer this
   /// over `type(of: self)` because if `self` is a ``DeclSyntax`` representing a
-  /// ``FunctionDeclSyntax``, `type(of: self)` will return `DeclSyntax`, while
+  /// ``FunctionDeclSyntax``, `type(of: self)` will return ``DeclSyntax``, while
   /// `syntaxNodeType` looks at the dynamic kind of this node and returns
   /// ``FunctionDeclSyntax``.
   public var syntaxNodeType: SyntaxProtocol.Type {
@@ -253,7 +253,7 @@ public extension SyntaxProtocol {
     return SyntaxChildren(_syntaxNode, viewMode: viewMode)
   }
 
-  /// The index of this node in a `SyntaxChildren` collection.
+  /// The index of this node in a ``SyntaxChildren`` collection.
   var index: SyntaxChildrenIndex {
     return SyntaxChildrenIndex(self.data.absoluteInfo)
   }
@@ -267,7 +267,7 @@ public extension SyntaxProtocol {
   }
 
   /// Whether the tree contained by this layout has any tokens with a
-  /// `TokenDiagnostic` of severity `warning`.
+  /// ``TokenDiagnostic`` of severity `warning`.
   var hasWarning: Bool {
     return raw.recursiveFlags.contains(.hasWarning)
   }
@@ -454,7 +454,7 @@ public extension SyntaxProtocol {
   /// the first token syntax contained by this node. Without such token, this
   /// property will return nil.
   ///
-  /// Note: `Trivia` is not able to represent invalid UTF-8 sequences. To get
+  /// Note: ``Trivia`` is not able to represent invalid UTF-8 sequences. To get
   /// the leading trivia text including all invalid UTF-8 sequences, use
   /// ```
   /// node.syntaxTextBytes.prefix(self.leadingTriviaLength.utf8Length)
@@ -472,7 +472,7 @@ public extension SyntaxProtocol {
   /// the last token syntax contained by this node. Without such token, this
   /// property will return nil.
   ///
-  /// Note: `Trivia` is not able to represent invalid UTF-8 sequences. To get
+  /// Note: ``Trivia`` is not able to represent invalid UTF-8 sequences. To get
   /// the leading trivia text including all invalid UTF-8 sequences, use
   /// ```
   /// node.syntaxTextBytes[(node.byteSize - node.trailingTriviaLength.utf8Length)...]
@@ -697,7 +697,7 @@ public extension SyntaxProtocol {
   }
 }
 
-/// Protocol for the enums nested inside `Syntax` nodes that enumerate all the
+/// Protocol for the enums nested inside ``Syntax`` nodes that enumerate all the
 /// possible types a child node might have.
 public protocol SyntaxChildChoices: SyntaxProtocol {}
 
@@ -731,7 +731,7 @@ public struct TokenSequence: Sequence {
   let node: Syntax
   let viewMode: SyntaxTreeViewMode
 
-  /// Construct a `TokenSequence` that walks all tokens in `node` in source order,
+  /// Construct a ``TokenSequence`` that walks all tokens in `node` in source order,
   /// recursively walking into child nodes.
   ///
   /// All nodes that are not visible in the given `viewMode` are skipped.
@@ -815,7 +815,7 @@ extension ReversedTokenSequence: CustomReflectable {
   }
 }
 
-/// `SyntaxNode` used to be a pervasive type name in SwiftSyntax that has been
+/// ``SyntaxNode`` used to be a pervasive type name in SwiftSyntax that has been
 /// replaced by the ``Syntax`` type.
 @available(*, unavailable, message: "use 'Syntax' instead")
 public struct SyntaxNode {}
diff --git a/Sources/SwiftSyntax/SyntaxArena.swift b/Sources/SwiftSyntax/SyntaxArena.swift
index b39f0403a82..a2079ae3d48 100644
--- a/Sources/SwiftSyntax/SyntaxArena.swift
+++ b/Sources/SwiftSyntax/SyntaxArena.swift
@@ -77,7 +77,7 @@ public class SyntaxArena {
     return allocator.allocate(RawSyntax?.self, count: count)
   }
 
-  /// Allcates a buffer of `RawTriviaPiece` with the given count, then returns
+  /// Allcates a buffer of ``RawTriviaPiece`` with the given count, then returns
   /// the uninitialized memory range as a `UnsafeMutableBufferPointer<RawTriviaPiece>`.
   func allocateRawTriviaPieceBuffer(
     count: Int
@@ -91,8 +91,8 @@ public class SyntaxArena {
     return allocator.allocate(UInt8.self, count: count)
   }
 
-  /// Copies the contents of a `SyntaxText` to the memory this arena manages,
-  /// and return the `SyntaxText` in the destiation.
+  /// Copies the contents of a ``SyntaxText`` to the memory this arena manages,
+  /// and return the ``SyntaxText`` in the destiation.
   @_spi(RawSyntax)
   public func intern(_ value: SyntaxText) -> SyntaxText {
     // Return the passed-in value if it's already managed by this arena.
@@ -106,7 +106,7 @@ public class SyntaxArena {
   }
 
   /// Copies a UTF8 sequence of `String` to the memory this arena manages, and
-  /// returns the copied string as a `SyntaxText`
+  /// returns the copied string as a ``SyntaxText``
   @_spi(RawSyntax)
   public func intern(_ value: String) -> SyntaxText {
     if value.isEmpty { return SyntaxText() }
@@ -126,7 +126,7 @@ public class SyntaxArena {
     return UnsafePointer(allocated)
   }
 
-  /// Adds an `SyntaxArena` to this arena as a "child". Do nothing if `arenaRef`
+  /// Adds an ``SyntaxArena`` to this arena as a "child". Do nothing if `arenaRef`
   /// refers `self`.
   ///
   /// When an arena added to another arena, it's owned and is never released
@@ -224,18 +224,18 @@ public class ParsingSyntaxArena: SyntaxArena {
     return sourceStart <= address && address < sourceStart.advanced(by: sourceBuffer.count)
   }
 
-  /// Parse `source` into a list of `RawTriviaPiece` using `parseTriviaFunction`.
+  /// Parse `source` into a list of ``RawTriviaPiece`` using `parseTriviaFunction`.
   @_spi(RawSyntax)
   public func parseTrivia(source: SyntaxText, position: TriviaPosition) -> [RawTriviaPiece] {
     return self.parseTriviaFunction(source, position)
   }
 }
 
-/// Unsafely unowned reference to `SyntaxArena`. The user is responsible to
-/// maintain the lifetime of the `SyntaxArena`.
+/// Unsafely unowned reference to ``SyntaxArena``. The user is responsible to
+/// maintain the lifetime of the ``SyntaxArena``.
 ///
-/// `RawSyntaxData` holds its `SyntaxArena` in this form to prevent their cyclic
-/// strong references. Also, passing around `SyntaxArena` in this form doesn't
+/// `RawSyntaxData` holds its ``SyntaxArena`` in this form to prevent their cyclic
+/// strong references. Also, passing around ``SyntaxArena`` in this form doesn't
 /// cause any ref-counting traffic.
 struct SyntaxArenaRef: Hashable {
   private let _value: Unmanaged<SyntaxArena>
@@ -244,7 +244,7 @@ struct SyntaxArenaRef: Hashable {
     self._value = .passUnretained(value)
   }
 
-  /// Returns the `SyntaxArena`
+  /// Returns the ``SyntaxArena``
   var value: SyntaxArena {
     get { self._value.takeUnretainedValue() }
   }
diff --git a/Sources/SwiftSyntax/SyntaxChildren.swift b/Sources/SwiftSyntax/SyntaxChildren.swift
index e9cd45ff6fe..23de716d842 100644
--- a/Sources/SwiftSyntax/SyntaxChildren.swift
+++ b/Sources/SwiftSyntax/SyntaxChildren.swift
@@ -13,7 +13,7 @@
 // MARK: - Index
 
 /// The data for an index in a syntax children collection that is not the end
-/// index. See `SyntaxChildrenIndex` for the representation of the end index.
+/// index. See ``SyntaxChildrenIndex`` for the representation of the end index.
 struct SyntaxChildrenIndexData: Comparable {
   /// The UTF-8 offset of the item at this index in the source file
   /// See `AbsoluteSyntaxPosition.offset`
@@ -167,7 +167,7 @@ struct RawSyntaxChildren: BidirectionalCollection {
     return Iterator(collection: self)
   }
 
-  /// Advance the given index by the given `RawSyntax` node.
+  /// Advance the given index by the given ``RawSyntax`` node.
   func index(_ index: Index, advancedBy node: RawSyntax?) -> Index {
     // We can assume a non-end index since advancing the end index is undefined
     // behaviour.
@@ -413,7 +413,7 @@ struct NonNilRawSyntaxChildren: BidirectionalCollection {
   }
 }
 
-/// Collection that contains the present child `Syntax` nodes of the given node.
+/// Collection that contains the present child ``Syntax`` nodes of the given node.
 public struct SyntaxChildren: BidirectionalCollection {
   /// ``SyntaxChildren`` is indexed by ``SyntaxChildrenIndex``.
   public typealias Index = SyntaxChildrenIndex
@@ -421,11 +421,11 @@ public struct SyntaxChildren: BidirectionalCollection {
   /// ``SyntaxChildren`` contains ``Syntax`` nodes.
   public typealias Element = Syntax
 
-  /// The collection that contains the raw child nodes. `Syntax` nodes are
+  /// The collection that contains the raw child nodes. ``Syntax`` nodes are
   /// generated from these.
   private let rawChildren: NonNilRawSyntaxChildren
 
-  /// The parent node of the children. Used to build the `Syntax` nodes.
+  /// The parent node of the children. Used to build the ``Syntax`` nodes.
   private let parent: Syntax
 
   /// The index of the first child in this collection.
diff --git a/Sources/SwiftSyntax/SyntaxData.swift b/Sources/SwiftSyntax/SyntaxData.swift
index 89952191d0e..b22ae3d2ed3 100644
--- a/Sources/SwiftSyntax/SyntaxData.swift
+++ b/Sources/SwiftSyntax/SyntaxData.swift
@@ -64,15 +64,15 @@ public struct SyntaxIndexInTree: Comparable, Hashable {
 
   static var zero: SyntaxIndexInTree = SyntaxIndexInTree(indexInTree: 0)
 
-  /// Assuming that this index points to the start of `Raw`, so that it points
-  /// to the next sibling of `Raw`.
+  /// Assuming that this index points to the start of ``Raw``, so that it points
+  /// to the next sibling of ``Raw``.
   func advancedBy(_ raw: RawSyntax?) -> SyntaxIndexInTree {
     let newIndexInTree = self.indexInTree + UInt32(truncatingIfNeeded: raw?.totalNodes ?? 0)
     return .init(indexInTree: newIndexInTree)
   }
 
-  /// Assuming that this index points to the next sibling of `Raw`, reverse it
-  /// so that it points to the start of `Raw`.
+  /// Assuming that this index points to the next sibling of ``Raw``, reverse it
+  /// so that it points to the start of ``Raw``.
   func reversedBy(_ raw: RawSyntax?) -> SyntaxIndexInTree {
     let newIndexInTree = self.indexInTree - UInt32(truncatingIfNeeded: raw?.totalNodes ?? 0)
     return .init(indexInTree: newIndexInTree)
diff --git a/Sources/SwiftSyntax/SyntaxText.swift b/Sources/SwiftSyntax/SyntaxText.swift
index 89c758111de..bf9cb761452 100644
--- a/Sources/SwiftSyntax/SyntaxText.swift
+++ b/Sources/SwiftSyntax/SyntaxText.swift
@@ -23,13 +23,13 @@
 /// This type does not own the string data. The data reside in some other buffer
 /// whose lifetime extends past that of the SyntaxText.
 ///
-/// `SyntaxText` is a `Collection` of `UInt8` which is _expected_ to be a UTF8
+/// ``SyntaxText`` is a `Collection` of `UInt8` which is _expected_ to be a UTF8
 /// encoded byte sequence. However, since that is essentialy just a span of a
 /// memory buffer, it may contain ill-formed UTF8 sequences. And their
 /// comparision (e.g.`==`, hasPrefix()) are purely based on the byte squences,
 /// without any Unicode normalization or anything.
 ///
-/// Since it's just a byte sequence, `SyntaxText` can represent the exact source
+/// Since it's just a byte sequence, ``SyntaxText`` can represent the exact source
 /// buffer regardless of whether it is a valid UTF8. When creating
 /// `Swift.String`, ill-formed UTF8 sequences are replaced with the Unicode
 /// replacement character (`\u{FFFD}`).
@@ -54,17 +54,17 @@ public struct SyntaxText {
     buffer = .init(start: baseAddress, count: count)
   }
 
-  /// Creates an empty `SyntaxText`
+  /// Creates an empty ``SyntaxText``
   public init() {
     self.init(baseAddress: nil, count: 0)
   }
 
-  /// Creates a `SyntaxText` from a `StaticString`
+  /// Creates a ``SyntaxText`` from a `StaticString`
   public init(_ string: StaticString) {
     self.init(baseAddress: string.utf8Start, count: string.utf8CodeUnitCount)
   }
 
-  /// Creates a `SyntaxText` over the same memory as the given slice.
+  /// Creates a ``SyntaxText`` over the same memory as the given slice.
   public init(rebasing slice: SubSequence) {
     self.init(
       baseAddress: slice.base.baseAddress?.advanced(by: slice.startIndex),
@@ -103,7 +103,7 @@ public struct SyntaxText {
     return (other.baseAddress! <= self.baseAddress! && self.baseAddress! + count <= other.baseAddress! + other.count)
   }
 
-  /// Returns `true` if `other` is a substring of this `SyntaxText`.
+  /// Returns `true` if `other` is a substring of this ``SyntaxText``.
   public func contains(_ other: SyntaxText) -> Bool {
     return firstRange(of: other) != nil
   }
@@ -145,12 +145,12 @@ public struct SyntaxText {
   }
 }
 
-/// `SyntaxText` is a collection of `UInt8`.
+/// ``SyntaxText`` is a collection of `UInt8`.
 extension SyntaxText: RandomAccessCollection {
   /// SyntaxText operates on bytes and each byte is represented by a `UInt8`.
   public typealias Element = UInt8
 
-  /// `SyntaxText` is a continuous memory region that can be accessed by an integer.
+  /// ``SyntaxText`` is a continuous memory region that can be accessed by an integer.
   public typealias Index = Int
 
   /// `Slice<SyntaxText>` represents a part of a ``SyntaxText``.
@@ -227,7 +227,7 @@ extension SyntaxText: CustomDebugStringConvertible {
 }
 
 extension String {
-  /// Creates a `String` from a `SyntaxText`.
+  /// Creates a `String` from a ``SyntaxText``.
   ///
   /// Ill-formed UTF-8 sequences in `syntaxText` are replaced with the Unicode
   /// replacement character `\u{FFFD}`.
@@ -246,7 +246,7 @@ extension String {
     }
   }
 
-  /// Runs `body` with a `SyntaxText` that refers the contiguous memory of this
+  /// Runs `body` with a ``SyntaxText`` that refers the contiguous memory of this
   /// string. Like `String.withUTF8(_:)`, this may mutate the string if this
   /// string was not contiguous.
   @_spi(RawSyntax)
diff --git a/Sources/SwiftSyntax/Trivia.swift b/Sources/SwiftSyntax/Trivia.swift
index d35a700480c..6a3117b5b27 100644
--- a/Sources/SwiftSyntax/Trivia.swift
+++ b/Sources/SwiftSyntax/Trivia.swift
@@ -43,21 +43,21 @@ public struct Trivia {
     return sourceLength.utf8Length
   }
 
-  /// Creates a new `Trivia` by appending the provided `TriviaPiece` to the end.
+  /// Creates a new ``Trivia`` by appending the provided ``TriviaPiece`` to the end.
   public func appending(_ piece: TriviaPiece) -> Trivia {
     var copy = pieces
     copy.append(piece)
     return Trivia(pieces: copy)
   }
 
-  /// Creates a new `Trivia` by appending the given trivia to the end.
+  /// Creates a new ``Trivia`` by appending the given trivia to the end.
   public func appending(_ trivia: Trivia) -> Trivia {
     var copy = pieces
     copy.append(contentsOf: trivia.pieces)
     return Trivia(pieces: copy)
   }
 
-  /// Creates a new `Trivia` by merging in the given trivia. Only includes one
+  /// Creates a new ``Trivia`` by merging in the given trivia. Only includes one
   /// copy of a common prefix of `self` and `trivia`.
   public func merging(_ trivia: Trivia) -> Trivia {
     let lhs = self.decomposed
@@ -70,19 +70,19 @@ public struct Trivia {
     return lhs.appending(rhs)
   }
 
-  /// Creates a new `Trivia` by merging the leading and trailing `Trivia`
+  /// Creates a new ``Trivia`` by merging the leading and trailing ``Trivia``
   /// of `triviaOf` into the end of `self`. Only includes one copy of any
   /// common prefixes.
   public func merging(triviaOf node: some SyntaxProtocol) -> Trivia {
     return merging(node.leadingTrivia).merging(node.trailingTrivia)
   }
 
-  /// Concatenates two collections of `Trivia` into one collection.
+  /// Concatenates two collections of ``Trivia`` into one collection.
   public static func + (lhs: Trivia, rhs: Trivia) -> Trivia {
     return lhs.appending(rhs)
   }
 
-  /// Concatenates two collections of `Trivia` into the left-hand side.
+  /// Concatenates two collections of ``Trivia`` into the left-hand side.
   public static func += (lhs: inout Trivia, rhs: Trivia) {
     lhs = lhs.appending(rhs)
   }
diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift
index c0b6d85f1a5..1f5a8df92f2 100644
--- a/Sources/SwiftSyntax/generated/Keyword.swift
+++ b/Sources/SwiftSyntax/generated/Keyword.swift
@@ -753,7 +753,7 @@ public enum Keyword: UInt8, Hashable {
   /// This is really unfortunate. Really, we should have a `switch` in
   /// `Keyword.defaultText` to return the keyword's kind but the constant lookup
   /// table is significantly faster. Ideally, we could also get the compiler to
-  /// constant-evaluate `Keyword.spi.defaultText` to a `SyntaxText` but I don't
+  /// constant-evaluate `Keyword.spi.defaultText` to a ``SyntaxText`` but I don't
   /// see how that's possible right now.
   private static let keywordTextLookupTable: [SyntaxText] = [
       "__consuming", 
diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
index c99e9a84d82..480d555bef5 100644
--- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-/// A `SyntaxVisitor` that can visit the nodes as generic `Syntax` values.
+/// A `SyntaxVisitor` that can visit the nodes as generic ``Syntax`` values.
 ///
 /// This subclass of `SyntaxVisitor` is slower than the type-specific visitation
 /// of `SyntaxVisitor`. Use `SyntaxAnyVisitor` if the `visitAny(_)` function
diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
index 678b4008615..a0437307654 100644
--- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
@@ -14,8 +14,8 @@
 
 // MARK: - DeclSyntax
 
-/// Protocol to which all `DeclSyntax` nodes conform. Extension point to add
-/// common methods to all `DeclSyntax` nodes.
+/// Protocol to which all ``DeclSyntax`` nodes conform. Extension point to add
+/// common methods to all ``DeclSyntax`` nodes.
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol DeclSyntaxProtocol: SyntaxProtocol {}
 
@@ -38,7 +38,7 @@ public extension Syntax {
 public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
   
-  /// Create a `DeclSyntax` node from a specialized syntax node.
+  /// Create a ``DeclSyntax`` node from a specialized syntax node.
   public init(_ syntax: some DeclSyntaxProtocol) {
     // We know this cast is going to succeed. Go through init(_: SyntaxData)
     // to do a sanity check and verify the kind matches in debug builds and get
@@ -46,7 +46,7 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self.init(syntax._syntaxNode.data)
   }
   
-  /// Create a `DeclSyntax` node from a specialized optional syntax node.
+  /// Create a ``DeclSyntax`` node from a specialized optional syntax node.
   public init?(_ syntax: (some DeclSyntaxProtocol)?) {
     guard let syntax = syntax else {
       return nil
@@ -61,7 +61,7 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self.init(syntax._syntaxNode.data)
   }
   
-  /// Create a `DeclSyntax` node from a specialized optional syntax node.
+  /// Create a ``DeclSyntax`` node from a specialized optional syntax node.
   public init?(fromProtocol syntax: DeclSyntaxProtocol?) {
     guard let syntax = syntax else {
       return nil
@@ -78,8 +78,8 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Creates a `DeclSyntax` node from the given `SyntaxData`. This assumes
-  /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
+  /// Creates a ``DeclSyntax`` node from the given ``SyntaxData``. This assumes
+  /// that the ``SyntaxData`` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
     switch data.raw.kind {
@@ -149,8 +149,8 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
 
 // MARK: - ExprSyntax
 
-/// Protocol to which all `ExprSyntax` nodes conform. Extension point to add
-/// common methods to all `ExprSyntax` nodes.
+/// Protocol to which all ``ExprSyntax`` nodes conform. Extension point to add
+/// common methods to all ``ExprSyntax`` nodes.
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol ExprSyntaxProtocol: SyntaxProtocol {}
 
@@ -173,7 +173,7 @@ public extension Syntax {
 public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
   
-  /// Create a `ExprSyntax` node from a specialized syntax node.
+  /// Create a ``ExprSyntax`` node from a specialized syntax node.
   public init(_ syntax: some ExprSyntaxProtocol) {
     // We know this cast is going to succeed. Go through init(_: SyntaxData)
     // to do a sanity check and verify the kind matches in debug builds and get
@@ -181,7 +181,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self.init(syntax._syntaxNode.data)
   }
   
-  /// Create a `ExprSyntax` node from a specialized optional syntax node.
+  /// Create a ``ExprSyntax`` node from a specialized optional syntax node.
   public init?(_ syntax: (some ExprSyntaxProtocol)?) {
     guard let syntax = syntax else {
       return nil
@@ -196,7 +196,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self.init(syntax._syntaxNode.data)
   }
   
-  /// Create a `ExprSyntax` node from a specialized optional syntax node.
+  /// Create a ``ExprSyntax`` node from a specialized optional syntax node.
   public init?(fromProtocol syntax: ExprSyntaxProtocol?) {
     guard let syntax = syntax else {
       return nil
@@ -213,8 +213,8 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Creates a `ExprSyntax` node from the given `SyntaxData`. This assumes
-  /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
+  /// Creates a ``ExprSyntax`` node from the given ``SyntaxData``. This assumes
+  /// that the ``SyntaxData`` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
     switch data.raw.kind {
@@ -311,8 +311,8 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
 
 // MARK: - PatternSyntax
 
-/// Protocol to which all `PatternSyntax` nodes conform. Extension point to add
-/// common methods to all `PatternSyntax` nodes.
+/// Protocol to which all ``PatternSyntax`` nodes conform. Extension point to add
+/// common methods to all ``PatternSyntax`` nodes.
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol PatternSyntaxProtocol: SyntaxProtocol {}
 
@@ -335,7 +335,7 @@ public extension Syntax {
 public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
   
-  /// Create a `PatternSyntax` node from a specialized syntax node.
+  /// Create a ``PatternSyntax`` node from a specialized syntax node.
   public init(_ syntax: some PatternSyntaxProtocol) {
     // We know this cast is going to succeed. Go through init(_: SyntaxData)
     // to do a sanity check and verify the kind matches in debug builds and get
@@ -343,7 +343,7 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     self.init(syntax._syntaxNode.data)
   }
   
-  /// Create a `PatternSyntax` node from a specialized optional syntax node.
+  /// Create a ``PatternSyntax`` node from a specialized optional syntax node.
   public init?(_ syntax: (some PatternSyntaxProtocol)?) {
     guard let syntax = syntax else {
       return nil
@@ -358,7 +358,7 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     self.init(syntax._syntaxNode.data)
   }
   
-  /// Create a `PatternSyntax` node from a specialized optional syntax node.
+  /// Create a ``PatternSyntax`` node from a specialized optional syntax node.
   public init?(fromProtocol syntax: PatternSyntaxProtocol?) {
     guard let syntax = syntax else {
       return nil
@@ -375,8 +375,8 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Creates a `PatternSyntax` node from the given `SyntaxData`. This assumes
-  /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
+  /// Creates a ``PatternSyntax`` node from the given ``SyntaxData``. This assumes
+  /// that the ``SyntaxData`` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
     switch data.raw.kind {
@@ -429,8 +429,8 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
 
 // MARK: - StmtSyntax
 
-/// Protocol to which all `StmtSyntax` nodes conform. Extension point to add
-/// common methods to all `StmtSyntax` nodes.
+/// Protocol to which all ``StmtSyntax`` nodes conform. Extension point to add
+/// common methods to all ``StmtSyntax`` nodes.
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol StmtSyntaxProtocol: SyntaxProtocol {}
 
@@ -453,7 +453,7 @@ public extension Syntax {
 public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
   
-  /// Create a `StmtSyntax` node from a specialized syntax node.
+  /// Create a ``StmtSyntax`` node from a specialized syntax node.
   public init(_ syntax: some StmtSyntaxProtocol) {
     // We know this cast is going to succeed. Go through init(_: SyntaxData)
     // to do a sanity check and verify the kind matches in debug builds and get
@@ -461,7 +461,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self.init(syntax._syntaxNode.data)
   }
   
-  /// Create a `StmtSyntax` node from a specialized optional syntax node.
+  /// Create a ``StmtSyntax`` node from a specialized optional syntax node.
   public init?(_ syntax: (some StmtSyntaxProtocol)?) {
     guard let syntax = syntax else {
       return nil
@@ -476,7 +476,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self.init(syntax._syntaxNode.data)
   }
   
-  /// Create a `StmtSyntax` node from a specialized optional syntax node.
+  /// Create a ``StmtSyntax`` node from a specialized optional syntax node.
   public init?(fromProtocol syntax: StmtSyntaxProtocol?) {
     guard let syntax = syntax else {
       return nil
@@ -493,8 +493,8 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Creates a `StmtSyntax` node from the given `SyntaxData`. This assumes
-  /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
+  /// Creates a ``StmtSyntax`` node from the given ``SyntaxData``. This assumes
+  /// that the ``SyntaxData`` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
     switch data.raw.kind {
@@ -556,8 +556,8 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
 
 // MARK: - TypeSyntax
 
-/// Protocol to which all `TypeSyntax` nodes conform. Extension point to add
-/// common methods to all `TypeSyntax` nodes.
+/// Protocol to which all ``TypeSyntax`` nodes conform. Extension point to add
+/// common methods to all ``TypeSyntax`` nodes.
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol TypeSyntaxProtocol: SyntaxProtocol {}
 
@@ -580,7 +580,7 @@ public extension Syntax {
 public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
   
-  /// Create a `TypeSyntax` node from a specialized syntax node.
+  /// Create a ``TypeSyntax`` node from a specialized syntax node.
   public init(_ syntax: some TypeSyntaxProtocol) {
     // We know this cast is going to succeed. Go through init(_: SyntaxData)
     // to do a sanity check and verify the kind matches in debug builds and get
@@ -588,7 +588,7 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self.init(syntax._syntaxNode.data)
   }
   
-  /// Create a `TypeSyntax` node from a specialized optional syntax node.
+  /// Create a ``TypeSyntax`` node from a specialized optional syntax node.
   public init?(_ syntax: (some TypeSyntaxProtocol)?) {
     guard let syntax = syntax else {
       return nil
@@ -603,7 +603,7 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self.init(syntax._syntaxNode.data)
   }
   
-  /// Create a `TypeSyntax` node from a specialized optional syntax node.
+  /// Create a ``TypeSyntax`` node from a specialized optional syntax node.
   public init?(fromProtocol syntax: TypeSyntaxProtocol?) {
     guard let syntax = syntax else {
       return nil
@@ -620,8 +620,8 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Creates a `TypeSyntax` node from the given `SyntaxData`. This assumes
-  /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
+  /// Creates a ``TypeSyntax`` node from the given ``SyntaxData``. This assumes
+  /// that the ``SyntaxData`` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
     switch data.raw.kind {
diff --git a/Sources/SwiftSyntax/generated/SyntaxCollections.swift b/Sources/SwiftSyntax/generated/SyntaxCollections.swift
index d31e32951ca..c4ce0b1018b 100644
--- a/Sources/SwiftSyntax/generated/SyntaxCollections.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxCollections.swift
@@ -28,8 +28,8 @@ public extension SyntaxCollection {
   }
 }
 
-/// `AccessorListSyntax` represents a collection of one or more
-/// `AccessorDeclSyntax` nodes. AccessorListSyntax behaves
+/// ``AccessorListSyntax`` represents a collection of one or more
+/// ``AccessorDeclSyntax`` nodes. ``AccessorListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable {
@@ -72,12 +72,12 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `AccessorListSyntax` by replacing the underlying layout with
+  /// Creates a new ``AccessorListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `AccessorListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``AccessorListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> AccessorListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -85,35 +85,35 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable {
     return AccessorListSyntax(newData)
   }
   
-  /// Creates a new `AccessorListSyntax` by appending the provided syntax element
+  /// Creates a new ``AccessorListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `AccessorListSyntax` with that element appended to the end.
+  /// - Returns: A new ``AccessorListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> AccessorListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AccessorListSyntax` by prepending the provided syntax element
+  /// Creates a new ``AccessorListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `AccessorListSyntax` with that element prepended to the
+  /// - Returns: A new ``AccessorListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> AccessorListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `AccessorListSyntax` by inserting the provided syntax element
+  /// Creates a new ``AccessorListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `AccessorListSyntax` with that element appended to the end.
+  /// - Returns: A new ``AccessorListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> AccessorListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -123,14 +123,14 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AccessorListSyntax` by replacing the syntax element
+  /// Creates a new ``AccessorListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `AccessorListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``AccessorListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> AccessorListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -140,11 +140,11 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AccessorListSyntax` by removing the syntax element at the
+  /// Creates a new ``AccessorListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `AccessorListSyntax` with the element at the provided index
+  /// - Returns: A new ``AccessorListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> AccessorListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -152,18 +152,18 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AccessorListSyntax` by removing the first element.
+  /// Creates a new ``AccessorListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `AccessorListSyntax` with the first element removed.
+  /// - Returns: A new ``AccessorListSyntax`` with the first element removed.
   public func removingFirst() -> AccessorListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AccessorListSyntax` by removing the last element.
+  /// Creates a new ``AccessorListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `AccessorListSyntax` with the last element removed.
+  /// - Returns: A new ``AccessorListSyntax`` with the last element removed.
   public func removingLast() -> AccessorListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -171,7 +171,7 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `AccessorListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``AccessorListSyntax`` to the `BidirectionalCollection` protocol.
 extension AccessorListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -237,8 +237,8 @@ extension AccessorListSyntax: BidirectionalCollection {
   }
 }
 
-/// `ArrayElementListSyntax` represents a collection of one or more
-/// `ArrayElementSyntax` nodes. ArrayElementListSyntax behaves
+/// ``ArrayElementListSyntax`` represents a collection of one or more
+/// ``ArrayElementSyntax`` nodes. ``ArrayElementListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable {
@@ -281,12 +281,12 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `ArrayElementListSyntax` by replacing the underlying layout with
+  /// Creates a new ``ArrayElementListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `ArrayElementListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``ArrayElementListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> ArrayElementListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -294,35 +294,35 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable {
     return ArrayElementListSyntax(newData)
   }
   
-  /// Creates a new `ArrayElementListSyntax` by appending the provided syntax element
+  /// Creates a new ``ArrayElementListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `ArrayElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ArrayElementListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> ArrayElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ArrayElementListSyntax` by prepending the provided syntax element
+  /// Creates a new ``ArrayElementListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `ArrayElementListSyntax` with that element prepended to the
+  /// - Returns: A new ``ArrayElementListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> ArrayElementListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `ArrayElementListSyntax` by inserting the provided syntax element
+  /// Creates a new ``ArrayElementListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `ArrayElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ArrayElementListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> ArrayElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -332,14 +332,14 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ArrayElementListSyntax` by replacing the syntax element
+  /// Creates a new ``ArrayElementListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `ArrayElementListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``ArrayElementListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> ArrayElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -349,11 +349,11 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ArrayElementListSyntax` by removing the syntax element at the
+  /// Creates a new ``ArrayElementListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `ArrayElementListSyntax` with the element at the provided index
+  /// - Returns: A new ``ArrayElementListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> ArrayElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -361,18 +361,18 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ArrayElementListSyntax` by removing the first element.
+  /// Creates a new ``ArrayElementListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `ArrayElementListSyntax` with the first element removed.
+  /// - Returns: A new ``ArrayElementListSyntax`` with the first element removed.
   public func removingFirst() -> ArrayElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ArrayElementListSyntax` by removing the last element.
+  /// Creates a new ``ArrayElementListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `ArrayElementListSyntax` with the last element removed.
+  /// - Returns: A new ``ArrayElementListSyntax`` with the last element removed.
   public func removingLast() -> ArrayElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -380,7 +380,7 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `ArrayElementListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``ArrayElementListSyntax`` to the `BidirectionalCollection` protocol.
 extension ArrayElementListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -446,8 +446,8 @@ extension ArrayElementListSyntax: BidirectionalCollection {
   }
 }
 
-/// `AttributeListSyntax` represents a collection of one or more
-/// `Syntax` nodes. AttributeListSyntax behaves
+/// ``AttributeListSyntax`` represents a collection of one or more
+/// ``Syntax`` nodes. ``AttributeListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable {
@@ -532,12 +532,12 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `AttributeListSyntax` by replacing the underlying layout with
+  /// Creates a new ``AttributeListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `AttributeListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``AttributeListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> AttributeListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -545,35 +545,35 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable {
     return AttributeListSyntax(newData)
   }
   
-  /// Creates a new `AttributeListSyntax` by appending the provided syntax element
+  /// Creates a new ``AttributeListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `AttributeListSyntax` with that element appended to the end.
+  /// - Returns: A new ``AttributeListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> AttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AttributeListSyntax` by prepending the provided syntax element
+  /// Creates a new ``AttributeListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `AttributeListSyntax` with that element prepended to the
+  /// - Returns: A new ``AttributeListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> AttributeListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `AttributeListSyntax` by inserting the provided syntax element
+  /// Creates a new ``AttributeListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `AttributeListSyntax` with that element appended to the end.
+  /// - Returns: A new ``AttributeListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> AttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -583,14 +583,14 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AttributeListSyntax` by replacing the syntax element
+  /// Creates a new ``AttributeListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `AttributeListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``AttributeListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> AttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -600,11 +600,11 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AttributeListSyntax` by removing the syntax element at the
+  /// Creates a new ``AttributeListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `AttributeListSyntax` with the element at the provided index
+  /// - Returns: A new ``AttributeListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> AttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -612,18 +612,18 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AttributeListSyntax` by removing the first element.
+  /// Creates a new ``AttributeListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `AttributeListSyntax` with the first element removed.
+  /// - Returns: A new ``AttributeListSyntax`` with the first element removed.
   public func removingFirst() -> AttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AttributeListSyntax` by removing the last element.
+  /// Creates a new ``AttributeListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `AttributeListSyntax` with the last element removed.
+  /// - Returns: A new ``AttributeListSyntax`` with the last element removed.
   public func removingLast() -> AttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -631,7 +631,7 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `AttributeListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``AttributeListSyntax`` to the `BidirectionalCollection` protocol.
 extension AttributeListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -697,8 +697,8 @@ extension AttributeListSyntax: BidirectionalCollection {
   }
 }
 
-/// `AvailabilitySpecListSyntax` represents a collection of one or more
-/// `AvailabilityArgumentSyntax` nodes. AvailabilitySpecListSyntax behaves
+/// ``AvailabilitySpecListSyntax`` represents a collection of one or more
+/// ``AvailabilityArgumentSyntax`` nodes. ``AvailabilitySpecListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable {
@@ -741,12 +741,12 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `AvailabilitySpecListSyntax` by replacing the underlying layout with
+  /// Creates a new ``AvailabilitySpecListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `AvailabilitySpecListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``AvailabilitySpecListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> AvailabilitySpecListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -754,35 +754,35 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable {
     return AvailabilitySpecListSyntax(newData)
   }
   
-  /// Creates a new `AvailabilitySpecListSyntax` by appending the provided syntax element
+  /// Creates a new ``AvailabilitySpecListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `AvailabilitySpecListSyntax` with that element appended to the end.
+  /// - Returns: A new ``AvailabilitySpecListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> AvailabilitySpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AvailabilitySpecListSyntax` by prepending the provided syntax element
+  /// Creates a new ``AvailabilitySpecListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `AvailabilitySpecListSyntax` with that element prepended to the
+  /// - Returns: A new ``AvailabilitySpecListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> AvailabilitySpecListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `AvailabilitySpecListSyntax` by inserting the provided syntax element
+  /// Creates a new ``AvailabilitySpecListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `AvailabilitySpecListSyntax` with that element appended to the end.
+  /// - Returns: A new ``AvailabilitySpecListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> AvailabilitySpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -792,14 +792,14 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AvailabilitySpecListSyntax` by replacing the syntax element
+  /// Creates a new ``AvailabilitySpecListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `AvailabilitySpecListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``AvailabilitySpecListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> AvailabilitySpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -809,11 +809,11 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AvailabilitySpecListSyntax` by removing the syntax element at the
+  /// Creates a new ``AvailabilitySpecListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `AvailabilitySpecListSyntax` with the element at the provided index
+  /// - Returns: A new ``AvailabilitySpecListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> AvailabilitySpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -821,18 +821,18 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AvailabilitySpecListSyntax` by removing the first element.
+  /// Creates a new ``AvailabilitySpecListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `AvailabilitySpecListSyntax` with the first element removed.
+  /// - Returns: A new ``AvailabilitySpecListSyntax`` with the first element removed.
   public func removingFirst() -> AvailabilitySpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AvailabilitySpecListSyntax` by removing the last element.
+  /// Creates a new ``AvailabilitySpecListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `AvailabilitySpecListSyntax` with the last element removed.
+  /// - Returns: A new ``AvailabilitySpecListSyntax`` with the last element removed.
   public func removingLast() -> AvailabilitySpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -840,7 +840,7 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `AvailabilitySpecListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``AvailabilitySpecListSyntax`` to the `BidirectionalCollection` protocol.
 extension AvailabilitySpecListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -906,8 +906,8 @@ extension AvailabilitySpecListSyntax: BidirectionalCollection {
   }
 }
 
-/// `AvailabilityVersionRestrictionListSyntax` represents a collection of one or more
-/// `AvailabilityVersionRestrictionListEntrySyntax` nodes. AvailabilityVersionRestrictionListSyntax behaves
+/// ``AvailabilityVersionRestrictionListSyntax`` represents a collection of one or more
+/// ``AvailabilityVersionRestrictionListEntrySyntax`` nodes. ``AvailabilityVersionRestrictionListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, SyntaxHashable {
@@ -950,12 +950,12 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax
     return layoutView.children.count
   }
   
-  /// Creates a new `AvailabilityVersionRestrictionListSyntax` by replacing the underlying layout with
+  /// Creates a new ``AvailabilityVersionRestrictionListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `AvailabilityVersionRestrictionListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``AvailabilityVersionRestrictionListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> AvailabilityVersionRestrictionListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -963,35 +963,35 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax
     return AvailabilityVersionRestrictionListSyntax(newData)
   }
   
-  /// Creates a new `AvailabilityVersionRestrictionListSyntax` by appending the provided syntax element
+  /// Creates a new ``AvailabilityVersionRestrictionListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `AvailabilityVersionRestrictionListSyntax` with that element appended to the end.
+  /// - Returns: A new ``AvailabilityVersionRestrictionListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> AvailabilityVersionRestrictionListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AvailabilityVersionRestrictionListSyntax` by prepending the provided syntax element
+  /// Creates a new ``AvailabilityVersionRestrictionListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `AvailabilityVersionRestrictionListSyntax` with that element prepended to the
+  /// - Returns: A new ``AvailabilityVersionRestrictionListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> AvailabilityVersionRestrictionListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `AvailabilityVersionRestrictionListSyntax` by inserting the provided syntax element
+  /// Creates a new ``AvailabilityVersionRestrictionListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `AvailabilityVersionRestrictionListSyntax` with that element appended to the end.
+  /// - Returns: A new ``AvailabilityVersionRestrictionListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> AvailabilityVersionRestrictionListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -1001,14 +1001,14 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AvailabilityVersionRestrictionListSyntax` by replacing the syntax element
+  /// Creates a new ``AvailabilityVersionRestrictionListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `AvailabilityVersionRestrictionListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``AvailabilityVersionRestrictionListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> AvailabilityVersionRestrictionListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -1018,11 +1018,11 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AvailabilityVersionRestrictionListSyntax` by removing the syntax element at the
+  /// Creates a new ``AvailabilityVersionRestrictionListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `AvailabilityVersionRestrictionListSyntax` with the element at the provided index
+  /// - Returns: A new ``AvailabilityVersionRestrictionListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> AvailabilityVersionRestrictionListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -1030,18 +1030,18 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AvailabilityVersionRestrictionListSyntax` by removing the first element.
+  /// Creates a new ``AvailabilityVersionRestrictionListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `AvailabilityVersionRestrictionListSyntax` with the first element removed.
+  /// - Returns: A new ``AvailabilityVersionRestrictionListSyntax`` with the first element removed.
   public func removingFirst() -> AvailabilityVersionRestrictionListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `AvailabilityVersionRestrictionListSyntax` by removing the last element.
+  /// Creates a new ``AvailabilityVersionRestrictionListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `AvailabilityVersionRestrictionListSyntax` with the last element removed.
+  /// - Returns: A new ``AvailabilityVersionRestrictionListSyntax`` with the last element removed.
   public func removingLast() -> AvailabilityVersionRestrictionListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -1049,7 +1049,7 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax
   }
 }
 
-/// Conformance for `AvailabilityVersionRestrictionListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``AvailabilityVersionRestrictionListSyntax`` to the `BidirectionalCollection` protocol.
 extension AvailabilityVersionRestrictionListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -1115,8 +1115,8 @@ extension AvailabilityVersionRestrictionListSyntax: BidirectionalCollection {
   }
 }
 
-/// `CaseItemListSyntax` represents a collection of one or more
-/// `CaseItemSyntax` nodes. CaseItemListSyntax behaves
+/// ``CaseItemListSyntax`` represents a collection of one or more
+/// ``CaseItemSyntax`` nodes. ``CaseItemListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable {
@@ -1159,12 +1159,12 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `CaseItemListSyntax` by replacing the underlying layout with
+  /// Creates a new ``CaseItemListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `CaseItemListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``CaseItemListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> CaseItemListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -1172,35 +1172,35 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable {
     return CaseItemListSyntax(newData)
   }
   
-  /// Creates a new `CaseItemListSyntax` by appending the provided syntax element
+  /// Creates a new ``CaseItemListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `CaseItemListSyntax` with that element appended to the end.
+  /// - Returns: A new ``CaseItemListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> CaseItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CaseItemListSyntax` by prepending the provided syntax element
+  /// Creates a new ``CaseItemListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `CaseItemListSyntax` with that element prepended to the
+  /// - Returns: A new ``CaseItemListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> CaseItemListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `CaseItemListSyntax` by inserting the provided syntax element
+  /// Creates a new ``CaseItemListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `CaseItemListSyntax` with that element appended to the end.
+  /// - Returns: A new ``CaseItemListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> CaseItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -1210,14 +1210,14 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CaseItemListSyntax` by replacing the syntax element
+  /// Creates a new ``CaseItemListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `CaseItemListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``CaseItemListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> CaseItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -1227,11 +1227,11 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CaseItemListSyntax` by removing the syntax element at the
+  /// Creates a new ``CaseItemListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `CaseItemListSyntax` with the element at the provided index
+  /// - Returns: A new ``CaseItemListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> CaseItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -1239,18 +1239,18 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CaseItemListSyntax` by removing the first element.
+  /// Creates a new ``CaseItemListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `CaseItemListSyntax` with the first element removed.
+  /// - Returns: A new ``CaseItemListSyntax`` with the first element removed.
   public func removingFirst() -> CaseItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CaseItemListSyntax` by removing the last element.
+  /// Creates a new ``CaseItemListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `CaseItemListSyntax` with the last element removed.
+  /// - Returns: A new ``CaseItemListSyntax`` with the last element removed.
   public func removingLast() -> CaseItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -1258,7 +1258,7 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `CaseItemListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``CaseItemListSyntax`` to the `BidirectionalCollection` protocol.
 extension CaseItemListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -1324,8 +1324,8 @@ extension CaseItemListSyntax: BidirectionalCollection {
   }
 }
 
-/// `CatchClauseListSyntax` represents a collection of one or more
-/// `CatchClauseSyntax` nodes. CatchClauseListSyntax behaves
+/// ``CatchClauseListSyntax`` represents a collection of one or more
+/// ``CatchClauseSyntax`` nodes. ``CatchClauseListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable {
@@ -1368,12 +1368,12 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `CatchClauseListSyntax` by replacing the underlying layout with
+  /// Creates a new ``CatchClauseListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `CatchClauseListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``CatchClauseListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> CatchClauseListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -1381,35 +1381,35 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable {
     return CatchClauseListSyntax(newData)
   }
   
-  /// Creates a new `CatchClauseListSyntax` by appending the provided syntax element
+  /// Creates a new ``CatchClauseListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `CatchClauseListSyntax` with that element appended to the end.
+  /// - Returns: A new ``CatchClauseListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> CatchClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CatchClauseListSyntax` by prepending the provided syntax element
+  /// Creates a new ``CatchClauseListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `CatchClauseListSyntax` with that element prepended to the
+  /// - Returns: A new ``CatchClauseListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> CatchClauseListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `CatchClauseListSyntax` by inserting the provided syntax element
+  /// Creates a new ``CatchClauseListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `CatchClauseListSyntax` with that element appended to the end.
+  /// - Returns: A new ``CatchClauseListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> CatchClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -1419,14 +1419,14 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CatchClauseListSyntax` by replacing the syntax element
+  /// Creates a new ``CatchClauseListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `CatchClauseListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``CatchClauseListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> CatchClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -1436,11 +1436,11 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CatchClauseListSyntax` by removing the syntax element at the
+  /// Creates a new ``CatchClauseListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `CatchClauseListSyntax` with the element at the provided index
+  /// - Returns: A new ``CatchClauseListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> CatchClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -1448,18 +1448,18 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CatchClauseListSyntax` by removing the first element.
+  /// Creates a new ``CatchClauseListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `CatchClauseListSyntax` with the first element removed.
+  /// - Returns: A new ``CatchClauseListSyntax`` with the first element removed.
   public func removingFirst() -> CatchClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CatchClauseListSyntax` by removing the last element.
+  /// Creates a new ``CatchClauseListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `CatchClauseListSyntax` with the last element removed.
+  /// - Returns: A new ``CatchClauseListSyntax`` with the last element removed.
   public func removingLast() -> CatchClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -1467,7 +1467,7 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `CatchClauseListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``CatchClauseListSyntax`` to the `BidirectionalCollection` protocol.
 extension CatchClauseListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -1533,8 +1533,8 @@ extension CatchClauseListSyntax: BidirectionalCollection {
   }
 }
 
-/// `CatchItemListSyntax` represents a collection of one or more
-/// `CatchItemSyntax` nodes. CatchItemListSyntax behaves
+/// ``CatchItemListSyntax`` represents a collection of one or more
+/// ``CatchItemSyntax`` nodes. ``CatchItemListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable {
@@ -1577,12 +1577,12 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `CatchItemListSyntax` by replacing the underlying layout with
+  /// Creates a new ``CatchItemListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `CatchItemListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``CatchItemListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> CatchItemListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -1590,35 +1590,35 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable {
     return CatchItemListSyntax(newData)
   }
   
-  /// Creates a new `CatchItemListSyntax` by appending the provided syntax element
+  /// Creates a new ``CatchItemListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `CatchItemListSyntax` with that element appended to the end.
+  /// - Returns: A new ``CatchItemListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> CatchItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CatchItemListSyntax` by prepending the provided syntax element
+  /// Creates a new ``CatchItemListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `CatchItemListSyntax` with that element prepended to the
+  /// - Returns: A new ``CatchItemListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> CatchItemListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `CatchItemListSyntax` by inserting the provided syntax element
+  /// Creates a new ``CatchItemListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `CatchItemListSyntax` with that element appended to the end.
+  /// - Returns: A new ``CatchItemListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> CatchItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -1628,14 +1628,14 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CatchItemListSyntax` by replacing the syntax element
+  /// Creates a new ``CatchItemListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `CatchItemListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``CatchItemListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> CatchItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -1645,11 +1645,11 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CatchItemListSyntax` by removing the syntax element at the
+  /// Creates a new ``CatchItemListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `CatchItemListSyntax` with the element at the provided index
+  /// - Returns: A new ``CatchItemListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> CatchItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -1657,18 +1657,18 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CatchItemListSyntax` by removing the first element.
+  /// Creates a new ``CatchItemListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `CatchItemListSyntax` with the first element removed.
+  /// - Returns: A new ``CatchItemListSyntax`` with the first element removed.
   public func removingFirst() -> CatchItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CatchItemListSyntax` by removing the last element.
+  /// Creates a new ``CatchItemListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `CatchItemListSyntax` with the last element removed.
+  /// - Returns: A new ``CatchItemListSyntax`` with the last element removed.
   public func removingLast() -> CatchItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -1676,7 +1676,7 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `CatchItemListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``CatchItemListSyntax`` to the `BidirectionalCollection` protocol.
 extension CatchItemListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -1742,8 +1742,8 @@ extension CatchItemListSyntax: BidirectionalCollection {
   }
 }
 
-/// `ClosureCaptureItemListSyntax` represents a collection of one or more
-/// `ClosureCaptureItemSyntax` nodes. ClosureCaptureItemListSyntax behaves
+/// ``ClosureCaptureItemListSyntax`` represents a collection of one or more
+/// ``ClosureCaptureItemSyntax`` nodes. ``ClosureCaptureItemListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable {
@@ -1786,12 +1786,12 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `ClosureCaptureItemListSyntax` by replacing the underlying layout with
+  /// Creates a new ``ClosureCaptureItemListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `ClosureCaptureItemListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``ClosureCaptureItemListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> ClosureCaptureItemListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -1799,35 +1799,35 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable {
     return ClosureCaptureItemListSyntax(newData)
   }
   
-  /// Creates a new `ClosureCaptureItemListSyntax` by appending the provided syntax element
+  /// Creates a new ``ClosureCaptureItemListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `ClosureCaptureItemListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ClosureCaptureItemListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> ClosureCaptureItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureCaptureItemListSyntax` by prepending the provided syntax element
+  /// Creates a new ``ClosureCaptureItemListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `ClosureCaptureItemListSyntax` with that element prepended to the
+  /// - Returns: A new ``ClosureCaptureItemListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> ClosureCaptureItemListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `ClosureCaptureItemListSyntax` by inserting the provided syntax element
+  /// Creates a new ``ClosureCaptureItemListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `ClosureCaptureItemListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ClosureCaptureItemListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> ClosureCaptureItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -1837,14 +1837,14 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureCaptureItemListSyntax` by replacing the syntax element
+  /// Creates a new ``ClosureCaptureItemListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `ClosureCaptureItemListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``ClosureCaptureItemListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> ClosureCaptureItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -1854,11 +1854,11 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureCaptureItemListSyntax` by removing the syntax element at the
+  /// Creates a new ``ClosureCaptureItemListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `ClosureCaptureItemListSyntax` with the element at the provided index
+  /// - Returns: A new ``ClosureCaptureItemListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> ClosureCaptureItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -1866,18 +1866,18 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureCaptureItemListSyntax` by removing the first element.
+  /// Creates a new ``ClosureCaptureItemListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `ClosureCaptureItemListSyntax` with the first element removed.
+  /// - Returns: A new ``ClosureCaptureItemListSyntax`` with the first element removed.
   public func removingFirst() -> ClosureCaptureItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureCaptureItemListSyntax` by removing the last element.
+  /// Creates a new ``ClosureCaptureItemListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `ClosureCaptureItemListSyntax` with the last element removed.
+  /// - Returns: A new ``ClosureCaptureItemListSyntax`` with the last element removed.
   public func removingLast() -> ClosureCaptureItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -1885,7 +1885,7 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `ClosureCaptureItemListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``ClosureCaptureItemListSyntax`` to the `BidirectionalCollection` protocol.
 extension ClosureCaptureItemListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -1951,8 +1951,8 @@ extension ClosureCaptureItemListSyntax: BidirectionalCollection {
   }
 }
 
-/// `ClosureParamListSyntax` represents a collection of one or more
-/// `ClosureParamSyntax` nodes. ClosureParamListSyntax behaves
+/// ``ClosureParamListSyntax`` represents a collection of one or more
+/// ``ClosureParamSyntax`` nodes. ``ClosureParamListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable {
@@ -1995,12 +1995,12 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `ClosureParamListSyntax` by replacing the underlying layout with
+  /// Creates a new ``ClosureParamListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `ClosureParamListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``ClosureParamListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> ClosureParamListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -2008,35 +2008,35 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable {
     return ClosureParamListSyntax(newData)
   }
   
-  /// Creates a new `ClosureParamListSyntax` by appending the provided syntax element
+  /// Creates a new ``ClosureParamListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `ClosureParamListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ClosureParamListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> ClosureParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureParamListSyntax` by prepending the provided syntax element
+  /// Creates a new ``ClosureParamListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `ClosureParamListSyntax` with that element prepended to the
+  /// - Returns: A new ``ClosureParamListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> ClosureParamListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `ClosureParamListSyntax` by inserting the provided syntax element
+  /// Creates a new ``ClosureParamListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `ClosureParamListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ClosureParamListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> ClosureParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -2046,14 +2046,14 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureParamListSyntax` by replacing the syntax element
+  /// Creates a new ``ClosureParamListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `ClosureParamListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``ClosureParamListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> ClosureParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -2063,11 +2063,11 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureParamListSyntax` by removing the syntax element at the
+  /// Creates a new ``ClosureParamListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `ClosureParamListSyntax` with the element at the provided index
+  /// - Returns: A new ``ClosureParamListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> ClosureParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -2075,18 +2075,18 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureParamListSyntax` by removing the first element.
+  /// Creates a new ``ClosureParamListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `ClosureParamListSyntax` with the first element removed.
+  /// - Returns: A new ``ClosureParamListSyntax`` with the first element removed.
   public func removingFirst() -> ClosureParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureParamListSyntax` by removing the last element.
+  /// Creates a new ``ClosureParamListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `ClosureParamListSyntax` with the last element removed.
+  /// - Returns: A new ``ClosureParamListSyntax`` with the last element removed.
   public func removingLast() -> ClosureParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -2094,7 +2094,7 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `ClosureParamListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``ClosureParamListSyntax`` to the `BidirectionalCollection` protocol.
 extension ClosureParamListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -2160,8 +2160,8 @@ extension ClosureParamListSyntax: BidirectionalCollection {
   }
 }
 
-/// `ClosureParameterListSyntax` represents a collection of one or more
-/// `ClosureParameterSyntax` nodes. ClosureParameterListSyntax behaves
+/// ``ClosureParameterListSyntax`` represents a collection of one or more
+/// ``ClosureParameterSyntax`` nodes. ``ClosureParameterListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable {
@@ -2204,12 +2204,12 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `ClosureParameterListSyntax` by replacing the underlying layout with
+  /// Creates a new ``ClosureParameterListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `ClosureParameterListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``ClosureParameterListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> ClosureParameterListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -2217,35 +2217,35 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return ClosureParameterListSyntax(newData)
   }
   
-  /// Creates a new `ClosureParameterListSyntax` by appending the provided syntax element
+  /// Creates a new ``ClosureParameterListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `ClosureParameterListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ClosureParameterListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> ClosureParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureParameterListSyntax` by prepending the provided syntax element
+  /// Creates a new ``ClosureParameterListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `ClosureParameterListSyntax` with that element prepended to the
+  /// - Returns: A new ``ClosureParameterListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> ClosureParameterListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `ClosureParameterListSyntax` by inserting the provided syntax element
+  /// Creates a new ``ClosureParameterListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `ClosureParameterListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ClosureParameterListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> ClosureParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -2255,14 +2255,14 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureParameterListSyntax` by replacing the syntax element
+  /// Creates a new ``ClosureParameterListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `ClosureParameterListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``ClosureParameterListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> ClosureParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -2272,11 +2272,11 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureParameterListSyntax` by removing the syntax element at the
+  /// Creates a new ``ClosureParameterListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `ClosureParameterListSyntax` with the element at the provided index
+  /// - Returns: A new ``ClosureParameterListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> ClosureParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -2284,18 +2284,18 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureParameterListSyntax` by removing the first element.
+  /// Creates a new ``ClosureParameterListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `ClosureParameterListSyntax` with the first element removed.
+  /// - Returns: A new ``ClosureParameterListSyntax`` with the first element removed.
   public func removingFirst() -> ClosureParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ClosureParameterListSyntax` by removing the last element.
+  /// Creates a new ``ClosureParameterListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `ClosureParameterListSyntax` with the last element removed.
+  /// - Returns: A new ``ClosureParameterListSyntax`` with the last element removed.
   public func removingLast() -> ClosureParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -2303,7 +2303,7 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `ClosureParameterListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``ClosureParameterListSyntax`` to the `BidirectionalCollection` protocol.
 extension ClosureParameterListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -2369,8 +2369,8 @@ extension ClosureParameterListSyntax: BidirectionalCollection {
   }
 }
 
-/// `CodeBlockItemListSyntax` represents a collection of one or more
-/// `CodeBlockItemSyntax` nodes. CodeBlockItemListSyntax behaves
+/// ``CodeBlockItemListSyntax`` represents a collection of one or more
+/// ``CodeBlockItemSyntax`` nodes. ``CodeBlockItemListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable {
@@ -2413,12 +2413,12 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `CodeBlockItemListSyntax` by replacing the underlying layout with
+  /// Creates a new ``CodeBlockItemListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `CodeBlockItemListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``CodeBlockItemListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> CodeBlockItemListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -2426,35 +2426,35 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable {
     return CodeBlockItemListSyntax(newData)
   }
   
-  /// Creates a new `CodeBlockItemListSyntax` by appending the provided syntax element
+  /// Creates a new ``CodeBlockItemListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `CodeBlockItemListSyntax` with that element appended to the end.
+  /// - Returns: A new ``CodeBlockItemListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> CodeBlockItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CodeBlockItemListSyntax` by prepending the provided syntax element
+  /// Creates a new ``CodeBlockItemListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `CodeBlockItemListSyntax` with that element prepended to the
+  /// - Returns: A new ``CodeBlockItemListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> CodeBlockItemListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `CodeBlockItemListSyntax` by inserting the provided syntax element
+  /// Creates a new ``CodeBlockItemListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `CodeBlockItemListSyntax` with that element appended to the end.
+  /// - Returns: A new ``CodeBlockItemListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> CodeBlockItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -2464,14 +2464,14 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CodeBlockItemListSyntax` by replacing the syntax element
+  /// Creates a new ``CodeBlockItemListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `CodeBlockItemListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``CodeBlockItemListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> CodeBlockItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -2481,11 +2481,11 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CodeBlockItemListSyntax` by removing the syntax element at the
+  /// Creates a new ``CodeBlockItemListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `CodeBlockItemListSyntax` with the element at the provided index
+  /// - Returns: A new ``CodeBlockItemListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> CodeBlockItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -2493,18 +2493,18 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CodeBlockItemListSyntax` by removing the first element.
+  /// Creates a new ``CodeBlockItemListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `CodeBlockItemListSyntax` with the first element removed.
+  /// - Returns: A new ``CodeBlockItemListSyntax`` with the first element removed.
   public func removingFirst() -> CodeBlockItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CodeBlockItemListSyntax` by removing the last element.
+  /// Creates a new ``CodeBlockItemListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `CodeBlockItemListSyntax` with the last element removed.
+  /// - Returns: A new ``CodeBlockItemListSyntax`` with the last element removed.
   public func removingLast() -> CodeBlockItemListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -2512,7 +2512,7 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `CodeBlockItemListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``CodeBlockItemListSyntax`` to the `BidirectionalCollection` protocol.
 extension CodeBlockItemListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -2578,8 +2578,8 @@ extension CodeBlockItemListSyntax: BidirectionalCollection {
   }
 }
 
-/// `CompositionTypeElementListSyntax` represents a collection of one or more
-/// `CompositionTypeElementSyntax` nodes. CompositionTypeElementListSyntax behaves
+/// ``CompositionTypeElementListSyntax`` represents a collection of one or more
+/// ``CompositionTypeElementSyntax`` nodes. ``CompositionTypeElementListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable {
@@ -2622,12 +2622,12 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable
     return layoutView.children.count
   }
   
-  /// Creates a new `CompositionTypeElementListSyntax` by replacing the underlying layout with
+  /// Creates a new ``CompositionTypeElementListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `CompositionTypeElementListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``CompositionTypeElementListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> CompositionTypeElementListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -2635,35 +2635,35 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable
     return CompositionTypeElementListSyntax(newData)
   }
   
-  /// Creates a new `CompositionTypeElementListSyntax` by appending the provided syntax element
+  /// Creates a new ``CompositionTypeElementListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `CompositionTypeElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``CompositionTypeElementListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> CompositionTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CompositionTypeElementListSyntax` by prepending the provided syntax element
+  /// Creates a new ``CompositionTypeElementListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `CompositionTypeElementListSyntax` with that element prepended to the
+  /// - Returns: A new ``CompositionTypeElementListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> CompositionTypeElementListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `CompositionTypeElementListSyntax` by inserting the provided syntax element
+  /// Creates a new ``CompositionTypeElementListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `CompositionTypeElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``CompositionTypeElementListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> CompositionTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -2673,14 +2673,14 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CompositionTypeElementListSyntax` by replacing the syntax element
+  /// Creates a new ``CompositionTypeElementListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `CompositionTypeElementListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``CompositionTypeElementListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> CompositionTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -2690,11 +2690,11 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CompositionTypeElementListSyntax` by removing the syntax element at the
+  /// Creates a new ``CompositionTypeElementListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `CompositionTypeElementListSyntax` with the element at the provided index
+  /// - Returns: A new ``CompositionTypeElementListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> CompositionTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -2702,18 +2702,18 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CompositionTypeElementListSyntax` by removing the first element.
+  /// Creates a new ``CompositionTypeElementListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `CompositionTypeElementListSyntax` with the first element removed.
+  /// - Returns: A new ``CompositionTypeElementListSyntax`` with the first element removed.
   public func removingFirst() -> CompositionTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `CompositionTypeElementListSyntax` by removing the last element.
+  /// Creates a new ``CompositionTypeElementListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `CompositionTypeElementListSyntax` with the last element removed.
+  /// - Returns: A new ``CompositionTypeElementListSyntax`` with the last element removed.
   public func removingLast() -> CompositionTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -2721,7 +2721,7 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable
   }
 }
 
-/// Conformance for `CompositionTypeElementListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``CompositionTypeElementListSyntax`` to the `BidirectionalCollection` protocol.
 extension CompositionTypeElementListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -2787,8 +2787,8 @@ extension CompositionTypeElementListSyntax: BidirectionalCollection {
   }
 }
 
-/// `ConditionElementListSyntax` represents a collection of one or more
-/// `ConditionElementSyntax` nodes. ConditionElementListSyntax behaves
+/// ``ConditionElementListSyntax`` represents a collection of one or more
+/// ``ConditionElementSyntax`` nodes. ``ConditionElementListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable {
@@ -2831,12 +2831,12 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `ConditionElementListSyntax` by replacing the underlying layout with
+  /// Creates a new ``ConditionElementListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `ConditionElementListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``ConditionElementListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> ConditionElementListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -2844,35 +2844,35 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable {
     return ConditionElementListSyntax(newData)
   }
   
-  /// Creates a new `ConditionElementListSyntax` by appending the provided syntax element
+  /// Creates a new ``ConditionElementListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `ConditionElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ConditionElementListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> ConditionElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ConditionElementListSyntax` by prepending the provided syntax element
+  /// Creates a new ``ConditionElementListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `ConditionElementListSyntax` with that element prepended to the
+  /// - Returns: A new ``ConditionElementListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> ConditionElementListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `ConditionElementListSyntax` by inserting the provided syntax element
+  /// Creates a new ``ConditionElementListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `ConditionElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ConditionElementListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> ConditionElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -2882,14 +2882,14 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ConditionElementListSyntax` by replacing the syntax element
+  /// Creates a new ``ConditionElementListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `ConditionElementListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``ConditionElementListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> ConditionElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -2899,11 +2899,11 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ConditionElementListSyntax` by removing the syntax element at the
+  /// Creates a new ``ConditionElementListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `ConditionElementListSyntax` with the element at the provided index
+  /// - Returns: A new ``ConditionElementListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> ConditionElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -2911,18 +2911,18 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ConditionElementListSyntax` by removing the first element.
+  /// Creates a new ``ConditionElementListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `ConditionElementListSyntax` with the first element removed.
+  /// - Returns: A new ``ConditionElementListSyntax`` with the first element removed.
   public func removingFirst() -> ConditionElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ConditionElementListSyntax` by removing the last element.
+  /// Creates a new ``ConditionElementListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `ConditionElementListSyntax` with the last element removed.
+  /// - Returns: A new ``ConditionElementListSyntax`` with the last element removed.
   public func removingLast() -> ConditionElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -2930,7 +2930,7 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `ConditionElementListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``ConditionElementListSyntax`` to the `BidirectionalCollection` protocol.
 extension ConditionElementListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -2996,8 +2996,8 @@ extension ConditionElementListSyntax: BidirectionalCollection {
   }
 }
 
-/// `DeclNameArgumentListSyntax` represents a collection of one or more
-/// `DeclNameArgumentSyntax` nodes. DeclNameArgumentListSyntax behaves
+/// ``DeclNameArgumentListSyntax`` represents a collection of one or more
+/// ``DeclNameArgumentSyntax`` nodes. ``DeclNameArgumentListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable {
@@ -3040,12 +3040,12 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `DeclNameArgumentListSyntax` by replacing the underlying layout with
+  /// Creates a new ``DeclNameArgumentListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `DeclNameArgumentListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``DeclNameArgumentListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> DeclNameArgumentListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -3053,35 +3053,35 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable {
     return DeclNameArgumentListSyntax(newData)
   }
   
-  /// Creates a new `DeclNameArgumentListSyntax` by appending the provided syntax element
+  /// Creates a new ``DeclNameArgumentListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `DeclNameArgumentListSyntax` with that element appended to the end.
+  /// - Returns: A new ``DeclNameArgumentListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> DeclNameArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DeclNameArgumentListSyntax` by prepending the provided syntax element
+  /// Creates a new ``DeclNameArgumentListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `DeclNameArgumentListSyntax` with that element prepended to the
+  /// - Returns: A new ``DeclNameArgumentListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> DeclNameArgumentListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `DeclNameArgumentListSyntax` by inserting the provided syntax element
+  /// Creates a new ``DeclNameArgumentListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `DeclNameArgumentListSyntax` with that element appended to the end.
+  /// - Returns: A new ``DeclNameArgumentListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> DeclNameArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -3091,14 +3091,14 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DeclNameArgumentListSyntax` by replacing the syntax element
+  /// Creates a new ``DeclNameArgumentListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `DeclNameArgumentListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``DeclNameArgumentListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> DeclNameArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -3108,11 +3108,11 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DeclNameArgumentListSyntax` by removing the syntax element at the
+  /// Creates a new ``DeclNameArgumentListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `DeclNameArgumentListSyntax` with the element at the provided index
+  /// - Returns: A new ``DeclNameArgumentListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> DeclNameArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -3120,18 +3120,18 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DeclNameArgumentListSyntax` by removing the first element.
+  /// Creates a new ``DeclNameArgumentListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `DeclNameArgumentListSyntax` with the first element removed.
+  /// - Returns: A new ``DeclNameArgumentListSyntax`` with the first element removed.
   public func removingFirst() -> DeclNameArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DeclNameArgumentListSyntax` by removing the last element.
+  /// Creates a new ``DeclNameArgumentListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `DeclNameArgumentListSyntax` with the last element removed.
+  /// - Returns: A new ``DeclNameArgumentListSyntax`` with the last element removed.
   public func removingLast() -> DeclNameArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -3139,7 +3139,7 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `DeclNameArgumentListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``DeclNameArgumentListSyntax`` to the `BidirectionalCollection` protocol.
 extension DeclNameArgumentListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -3205,8 +3205,8 @@ extension DeclNameArgumentListSyntax: BidirectionalCollection {
   }
 }
 
-/// `DesignatedTypeListSyntax` represents a collection of one or more
-/// `DesignatedTypeElementSyntax` nodes. DesignatedTypeListSyntax behaves
+/// ``DesignatedTypeListSyntax`` represents a collection of one or more
+/// ``DesignatedTypeElementSyntax`` nodes. ``DesignatedTypeListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable {
@@ -3249,12 +3249,12 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `DesignatedTypeListSyntax` by replacing the underlying layout with
+  /// Creates a new ``DesignatedTypeListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `DesignatedTypeListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``DesignatedTypeListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> DesignatedTypeListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -3262,35 +3262,35 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable {
     return DesignatedTypeListSyntax(newData)
   }
   
-  /// Creates a new `DesignatedTypeListSyntax` by appending the provided syntax element
+  /// Creates a new ``DesignatedTypeListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `DesignatedTypeListSyntax` with that element appended to the end.
+  /// - Returns: A new ``DesignatedTypeListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> DesignatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DesignatedTypeListSyntax` by prepending the provided syntax element
+  /// Creates a new ``DesignatedTypeListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `DesignatedTypeListSyntax` with that element prepended to the
+  /// - Returns: A new ``DesignatedTypeListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> DesignatedTypeListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `DesignatedTypeListSyntax` by inserting the provided syntax element
+  /// Creates a new ``DesignatedTypeListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `DesignatedTypeListSyntax` with that element appended to the end.
+  /// - Returns: A new ``DesignatedTypeListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> DesignatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -3300,14 +3300,14 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DesignatedTypeListSyntax` by replacing the syntax element
+  /// Creates a new ``DesignatedTypeListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `DesignatedTypeListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``DesignatedTypeListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> DesignatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -3317,11 +3317,11 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DesignatedTypeListSyntax` by removing the syntax element at the
+  /// Creates a new ``DesignatedTypeListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `DesignatedTypeListSyntax` with the element at the provided index
+  /// - Returns: A new ``DesignatedTypeListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> DesignatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -3329,18 +3329,18 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DesignatedTypeListSyntax` by removing the first element.
+  /// Creates a new ``DesignatedTypeListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `DesignatedTypeListSyntax` with the first element removed.
+  /// - Returns: A new ``DesignatedTypeListSyntax`` with the first element removed.
   public func removingFirst() -> DesignatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DesignatedTypeListSyntax` by removing the last element.
+  /// Creates a new ``DesignatedTypeListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `DesignatedTypeListSyntax` with the last element removed.
+  /// - Returns: A new ``DesignatedTypeListSyntax`` with the last element removed.
   public func removingLast() -> DesignatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -3348,7 +3348,7 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `DesignatedTypeListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``DesignatedTypeListSyntax`` to the `BidirectionalCollection` protocol.
 extension DesignatedTypeListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -3414,8 +3414,8 @@ extension DesignatedTypeListSyntax: BidirectionalCollection {
   }
 }
 
-/// `DictionaryElementListSyntax` represents a collection of one or more
-/// `DictionaryElementSyntax` nodes. DictionaryElementListSyntax behaves
+/// ``DictionaryElementListSyntax`` represents a collection of one or more
+/// ``DictionaryElementSyntax`` nodes. ``DictionaryElementListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable {
@@ -3458,12 +3458,12 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `DictionaryElementListSyntax` by replacing the underlying layout with
+  /// Creates a new ``DictionaryElementListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `DictionaryElementListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``DictionaryElementListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> DictionaryElementListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -3471,35 +3471,35 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable {
     return DictionaryElementListSyntax(newData)
   }
   
-  /// Creates a new `DictionaryElementListSyntax` by appending the provided syntax element
+  /// Creates a new ``DictionaryElementListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `DictionaryElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``DictionaryElementListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> DictionaryElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DictionaryElementListSyntax` by prepending the provided syntax element
+  /// Creates a new ``DictionaryElementListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `DictionaryElementListSyntax` with that element prepended to the
+  /// - Returns: A new ``DictionaryElementListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> DictionaryElementListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `DictionaryElementListSyntax` by inserting the provided syntax element
+  /// Creates a new ``DictionaryElementListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `DictionaryElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``DictionaryElementListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> DictionaryElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -3509,14 +3509,14 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DictionaryElementListSyntax` by replacing the syntax element
+  /// Creates a new ``DictionaryElementListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `DictionaryElementListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``DictionaryElementListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> DictionaryElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -3526,11 +3526,11 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DictionaryElementListSyntax` by removing the syntax element at the
+  /// Creates a new ``DictionaryElementListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `DictionaryElementListSyntax` with the element at the provided index
+  /// - Returns: A new ``DictionaryElementListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> DictionaryElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -3538,18 +3538,18 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DictionaryElementListSyntax` by removing the first element.
+  /// Creates a new ``DictionaryElementListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `DictionaryElementListSyntax` with the first element removed.
+  /// - Returns: A new ``DictionaryElementListSyntax`` with the first element removed.
   public func removingFirst() -> DictionaryElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DictionaryElementListSyntax` by removing the last element.
+  /// Creates a new ``DictionaryElementListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `DictionaryElementListSyntax` with the last element removed.
+  /// - Returns: A new ``DictionaryElementListSyntax`` with the last element removed.
   public func removingLast() -> DictionaryElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -3557,7 +3557,7 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `DictionaryElementListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``DictionaryElementListSyntax`` to the `BidirectionalCollection` protocol.
 extension DictionaryElementListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -3623,8 +3623,8 @@ extension DictionaryElementListSyntax: BidirectionalCollection {
   }
 }
 
-/// `DifferentiabilityParamListSyntax` represents a collection of one or more
-/// `DifferentiabilityParamSyntax` nodes. DifferentiabilityParamListSyntax behaves
+/// ``DifferentiabilityParamListSyntax`` represents a collection of one or more
+/// ``DifferentiabilityParamSyntax`` nodes. ``DifferentiabilityParamListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable {
@@ -3667,12 +3667,12 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable
     return layoutView.children.count
   }
   
-  /// Creates a new `DifferentiabilityParamListSyntax` by replacing the underlying layout with
+  /// Creates a new ``DifferentiabilityParamListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `DifferentiabilityParamListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``DifferentiabilityParamListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> DifferentiabilityParamListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -3680,35 +3680,35 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable
     return DifferentiabilityParamListSyntax(newData)
   }
   
-  /// Creates a new `DifferentiabilityParamListSyntax` by appending the provided syntax element
+  /// Creates a new ``DifferentiabilityParamListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `DifferentiabilityParamListSyntax` with that element appended to the end.
+  /// - Returns: A new ``DifferentiabilityParamListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> DifferentiabilityParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DifferentiabilityParamListSyntax` by prepending the provided syntax element
+  /// Creates a new ``DifferentiabilityParamListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `DifferentiabilityParamListSyntax` with that element prepended to the
+  /// - Returns: A new ``DifferentiabilityParamListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> DifferentiabilityParamListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `DifferentiabilityParamListSyntax` by inserting the provided syntax element
+  /// Creates a new ``DifferentiabilityParamListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `DifferentiabilityParamListSyntax` with that element appended to the end.
+  /// - Returns: A new ``DifferentiabilityParamListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> DifferentiabilityParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -3718,14 +3718,14 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DifferentiabilityParamListSyntax` by replacing the syntax element
+  /// Creates a new ``DifferentiabilityParamListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `DifferentiabilityParamListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``DifferentiabilityParamListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> DifferentiabilityParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -3735,11 +3735,11 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DifferentiabilityParamListSyntax` by removing the syntax element at the
+  /// Creates a new ``DifferentiabilityParamListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `DifferentiabilityParamListSyntax` with the element at the provided index
+  /// - Returns: A new ``DifferentiabilityParamListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> DifferentiabilityParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -3747,18 +3747,18 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DifferentiabilityParamListSyntax` by removing the first element.
+  /// Creates a new ``DifferentiabilityParamListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `DifferentiabilityParamListSyntax` with the first element removed.
+  /// - Returns: A new ``DifferentiabilityParamListSyntax`` with the first element removed.
   public func removingFirst() -> DifferentiabilityParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DifferentiabilityParamListSyntax` by removing the last element.
+  /// Creates a new ``DifferentiabilityParamListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `DifferentiabilityParamListSyntax` with the last element removed.
+  /// - Returns: A new ``DifferentiabilityParamListSyntax`` with the last element removed.
   public func removingLast() -> DifferentiabilityParamListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -3766,7 +3766,7 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable
   }
 }
 
-/// Conformance for `DifferentiabilityParamListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``DifferentiabilityParamListSyntax`` to the `BidirectionalCollection` protocol.
 extension DifferentiabilityParamListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -3873,12 +3873,12 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas
     return layoutView.children.count
   }
   
-  /// Creates a new `DocumentationAttributeArgumentsSyntax` by replacing the underlying layout with
+  /// Creates a new ``DocumentationAttributeArgumentsSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `DocumentationAttributeArgumentsSyntax` with the new layout underlying it.
+  /// - Returns: A new ``DocumentationAttributeArgumentsSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> DocumentationAttributeArgumentsSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -3886,35 +3886,35 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas
     return DocumentationAttributeArgumentsSyntax(newData)
   }
   
-  /// Creates a new `DocumentationAttributeArgumentsSyntax` by appending the provided syntax element
+  /// Creates a new ``DocumentationAttributeArgumentsSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `DocumentationAttributeArgumentsSyntax` with that element appended to the end.
+  /// - Returns: A new ``DocumentationAttributeArgumentsSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> DocumentationAttributeArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DocumentationAttributeArgumentsSyntax` by prepending the provided syntax element
+  /// Creates a new ``DocumentationAttributeArgumentsSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `DocumentationAttributeArgumentsSyntax` with that element prepended to the
+  /// - Returns: A new ``DocumentationAttributeArgumentsSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> DocumentationAttributeArgumentsSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `DocumentationAttributeArgumentsSyntax` by inserting the provided syntax element
+  /// Creates a new ``DocumentationAttributeArgumentsSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `DocumentationAttributeArgumentsSyntax` with that element appended to the end.
+  /// - Returns: A new ``DocumentationAttributeArgumentsSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> DocumentationAttributeArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -3924,14 +3924,14 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DocumentationAttributeArgumentsSyntax` by replacing the syntax element
+  /// Creates a new ``DocumentationAttributeArgumentsSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `DocumentationAttributeArgumentsSyntax` with the new element at the provided index.
+  /// - Returns: A new ``DocumentationAttributeArgumentsSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> DocumentationAttributeArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -3941,11 +3941,11 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DocumentationAttributeArgumentsSyntax` by removing the syntax element at the
+  /// Creates a new ``DocumentationAttributeArgumentsSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `DocumentationAttributeArgumentsSyntax` with the element at the provided index
+  /// - Returns: A new ``DocumentationAttributeArgumentsSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> DocumentationAttributeArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -3953,18 +3953,18 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DocumentationAttributeArgumentsSyntax` by removing the first element.
+  /// Creates a new ``DocumentationAttributeArgumentsSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `DocumentationAttributeArgumentsSyntax` with the first element removed.
+  /// - Returns: A new ``DocumentationAttributeArgumentsSyntax`` with the first element removed.
   public func removingFirst() -> DocumentationAttributeArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `DocumentationAttributeArgumentsSyntax` by removing the last element.
+  /// Creates a new ``DocumentationAttributeArgumentsSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `DocumentationAttributeArgumentsSyntax` with the last element removed.
+  /// - Returns: A new ``DocumentationAttributeArgumentsSyntax`` with the last element removed.
   public func removingLast() -> DocumentationAttributeArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -3972,7 +3972,7 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas
   }
 }
 
-/// Conformance for `DocumentationAttributeArgumentsSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``DocumentationAttributeArgumentsSyntax`` to the `BidirectionalCollection` protocol.
 extension DocumentationAttributeArgumentsSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -4079,12 +4079,12 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `EffectsArgumentsSyntax` by replacing the underlying layout with
+  /// Creates a new ``EffectsArgumentsSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `EffectsArgumentsSyntax` with the new layout underlying it.
+  /// - Returns: A new ``EffectsArgumentsSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> EffectsArgumentsSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -4092,35 +4092,35 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable {
     return EffectsArgumentsSyntax(newData)
   }
   
-  /// Creates a new `EffectsArgumentsSyntax` by appending the provided syntax element
+  /// Creates a new ``EffectsArgumentsSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `EffectsArgumentsSyntax` with that element appended to the end.
+  /// - Returns: A new ``EffectsArgumentsSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> EffectsArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EffectsArgumentsSyntax` by prepending the provided syntax element
+  /// Creates a new ``EffectsArgumentsSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `EffectsArgumentsSyntax` with that element prepended to the
+  /// - Returns: A new ``EffectsArgumentsSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> EffectsArgumentsSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `EffectsArgumentsSyntax` by inserting the provided syntax element
+  /// Creates a new ``EffectsArgumentsSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `EffectsArgumentsSyntax` with that element appended to the end.
+  /// - Returns: A new ``EffectsArgumentsSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> EffectsArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -4130,14 +4130,14 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EffectsArgumentsSyntax` by replacing the syntax element
+  /// Creates a new ``EffectsArgumentsSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `EffectsArgumentsSyntax` with the new element at the provided index.
+  /// - Returns: A new ``EffectsArgumentsSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> EffectsArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -4147,11 +4147,11 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EffectsArgumentsSyntax` by removing the syntax element at the
+  /// Creates a new ``EffectsArgumentsSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `EffectsArgumentsSyntax` with the element at the provided index
+  /// - Returns: A new ``EffectsArgumentsSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> EffectsArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -4159,18 +4159,18 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EffectsArgumentsSyntax` by removing the first element.
+  /// Creates a new ``EffectsArgumentsSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `EffectsArgumentsSyntax` with the first element removed.
+  /// - Returns: A new ``EffectsArgumentsSyntax`` with the first element removed.
   public func removingFirst() -> EffectsArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EffectsArgumentsSyntax` by removing the last element.
+  /// Creates a new ``EffectsArgumentsSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `EffectsArgumentsSyntax` with the last element removed.
+  /// - Returns: A new ``EffectsArgumentsSyntax`` with the last element removed.
   public func removingLast() -> EffectsArgumentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -4178,7 +4178,7 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `EffectsArgumentsSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``EffectsArgumentsSyntax`` to the `BidirectionalCollection` protocol.
 extension EffectsArgumentsSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -4285,12 +4285,12 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `EnumCaseElementListSyntax` by replacing the underlying layout with
+  /// Creates a new ``EnumCaseElementListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `EnumCaseElementListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``EnumCaseElementListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> EnumCaseElementListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -4298,35 +4298,35 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable {
     return EnumCaseElementListSyntax(newData)
   }
   
-  /// Creates a new `EnumCaseElementListSyntax` by appending the provided syntax element
+  /// Creates a new ``EnumCaseElementListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `EnumCaseElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``EnumCaseElementListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> EnumCaseElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EnumCaseElementListSyntax` by prepending the provided syntax element
+  /// Creates a new ``EnumCaseElementListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `EnumCaseElementListSyntax` with that element prepended to the
+  /// - Returns: A new ``EnumCaseElementListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> EnumCaseElementListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `EnumCaseElementListSyntax` by inserting the provided syntax element
+  /// Creates a new ``EnumCaseElementListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `EnumCaseElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``EnumCaseElementListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> EnumCaseElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -4336,14 +4336,14 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EnumCaseElementListSyntax` by replacing the syntax element
+  /// Creates a new ``EnumCaseElementListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `EnumCaseElementListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``EnumCaseElementListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> EnumCaseElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -4353,11 +4353,11 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EnumCaseElementListSyntax` by removing the syntax element at the
+  /// Creates a new ``EnumCaseElementListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `EnumCaseElementListSyntax` with the element at the provided index
+  /// - Returns: A new ``EnumCaseElementListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> EnumCaseElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -4365,18 +4365,18 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EnumCaseElementListSyntax` by removing the first element.
+  /// Creates a new ``EnumCaseElementListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `EnumCaseElementListSyntax` with the first element removed.
+  /// - Returns: A new ``EnumCaseElementListSyntax`` with the first element removed.
   public func removingFirst() -> EnumCaseElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EnumCaseElementListSyntax` by removing the last element.
+  /// Creates a new ``EnumCaseElementListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `EnumCaseElementListSyntax` with the last element removed.
+  /// - Returns: A new ``EnumCaseElementListSyntax`` with the last element removed.
   public func removingLast() -> EnumCaseElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -4384,7 +4384,7 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `EnumCaseElementListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``EnumCaseElementListSyntax`` to the `BidirectionalCollection` protocol.
 extension EnumCaseElementListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -4450,8 +4450,8 @@ extension EnumCaseElementListSyntax: BidirectionalCollection {
   }
 }
 
-/// `EnumCaseParameterListSyntax` represents a collection of one or more
-/// `EnumCaseParameterSyntax` nodes. EnumCaseParameterListSyntax behaves
+/// ``EnumCaseParameterListSyntax`` represents a collection of one or more
+/// ``EnumCaseParameterSyntax`` nodes. ``EnumCaseParameterListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable {
@@ -4494,12 +4494,12 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `EnumCaseParameterListSyntax` by replacing the underlying layout with
+  /// Creates a new ``EnumCaseParameterListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `EnumCaseParameterListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``EnumCaseParameterListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> EnumCaseParameterListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -4507,35 +4507,35 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return EnumCaseParameterListSyntax(newData)
   }
   
-  /// Creates a new `EnumCaseParameterListSyntax` by appending the provided syntax element
+  /// Creates a new ``EnumCaseParameterListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `EnumCaseParameterListSyntax` with that element appended to the end.
+  /// - Returns: A new ``EnumCaseParameterListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> EnumCaseParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EnumCaseParameterListSyntax` by prepending the provided syntax element
+  /// Creates a new ``EnumCaseParameterListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `EnumCaseParameterListSyntax` with that element prepended to the
+  /// - Returns: A new ``EnumCaseParameterListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> EnumCaseParameterListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `EnumCaseParameterListSyntax` by inserting the provided syntax element
+  /// Creates a new ``EnumCaseParameterListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `EnumCaseParameterListSyntax` with that element appended to the end.
+  /// - Returns: A new ``EnumCaseParameterListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> EnumCaseParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -4545,14 +4545,14 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EnumCaseParameterListSyntax` by replacing the syntax element
+  /// Creates a new ``EnumCaseParameterListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `EnumCaseParameterListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``EnumCaseParameterListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> EnumCaseParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -4562,11 +4562,11 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EnumCaseParameterListSyntax` by removing the syntax element at the
+  /// Creates a new ``EnumCaseParameterListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `EnumCaseParameterListSyntax` with the element at the provided index
+  /// - Returns: A new ``EnumCaseParameterListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> EnumCaseParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -4574,18 +4574,18 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EnumCaseParameterListSyntax` by removing the first element.
+  /// Creates a new ``EnumCaseParameterListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `EnumCaseParameterListSyntax` with the first element removed.
+  /// - Returns: A new ``EnumCaseParameterListSyntax`` with the first element removed.
   public func removingFirst() -> EnumCaseParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `EnumCaseParameterListSyntax` by removing the last element.
+  /// Creates a new ``EnumCaseParameterListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `EnumCaseParameterListSyntax` with the last element removed.
+  /// - Returns: A new ``EnumCaseParameterListSyntax`` with the last element removed.
   public func removingLast() -> EnumCaseParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -4593,7 +4593,7 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `EnumCaseParameterListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``EnumCaseParameterListSyntax`` to the `BidirectionalCollection` protocol.
 extension EnumCaseParameterListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -4659,7 +4659,7 @@ extension EnumCaseParameterListSyntax: BidirectionalCollection {
   }
 }
 
-/// A list of expressions connected by operators. This list is contained by a `SequenceExprSyntax`.
+/// A list of expressions connected by operators. This list is contained by a ``SequenceExprSyntax``.
 public struct ExprListSyntax: SyntaxCollection, SyntaxHashable {
   public typealias Element = ExprSyntax
   
@@ -4700,12 +4700,12 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `ExprListSyntax` by replacing the underlying layout with
+  /// Creates a new ``ExprListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `ExprListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``ExprListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> ExprListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -4713,35 +4713,35 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable {
     return ExprListSyntax(newData)
   }
   
-  /// Creates a new `ExprListSyntax` by appending the provided syntax element
+  /// Creates a new ``ExprListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `ExprListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ExprListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> ExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ExprListSyntax` by prepending the provided syntax element
+  /// Creates a new ``ExprListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `ExprListSyntax` with that element prepended to the
+  /// - Returns: A new ``ExprListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> ExprListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `ExprListSyntax` by inserting the provided syntax element
+  /// Creates a new ``ExprListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `ExprListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ExprListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> ExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -4751,14 +4751,14 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ExprListSyntax` by replacing the syntax element
+  /// Creates a new ``ExprListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `ExprListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``ExprListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> ExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -4768,11 +4768,11 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ExprListSyntax` by removing the syntax element at the
+  /// Creates a new ``ExprListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `ExprListSyntax` with the element at the provided index
+  /// - Returns: A new ``ExprListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> ExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -4780,18 +4780,18 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ExprListSyntax` by removing the first element.
+  /// Creates a new ``ExprListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `ExprListSyntax` with the first element removed.
+  /// - Returns: A new ``ExprListSyntax`` with the first element removed.
   public func removingFirst() -> ExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ExprListSyntax` by removing the last element.
+  /// Creates a new ``ExprListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `ExprListSyntax` with the last element removed.
+  /// - Returns: A new ``ExprListSyntax`` with the last element removed.
   public func removingLast() -> ExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -4799,7 +4799,7 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `ExprListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``ExprListSyntax`` to the `BidirectionalCollection` protocol.
 extension ExprListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -4865,8 +4865,8 @@ extension ExprListSyntax: BidirectionalCollection {
   }
 }
 
-/// `FunctionParameterListSyntax` represents a collection of one or more
-/// `FunctionParameterSyntax` nodes. FunctionParameterListSyntax behaves
+/// ``FunctionParameterListSyntax`` represents a collection of one or more
+/// ``FunctionParameterSyntax`` nodes. ``FunctionParameterListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable {
@@ -4909,12 +4909,12 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `FunctionParameterListSyntax` by replacing the underlying layout with
+  /// Creates a new ``FunctionParameterListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `FunctionParameterListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``FunctionParameterListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> FunctionParameterListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -4922,35 +4922,35 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return FunctionParameterListSyntax(newData)
   }
   
-  /// Creates a new `FunctionParameterListSyntax` by appending the provided syntax element
+  /// Creates a new ``FunctionParameterListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `FunctionParameterListSyntax` with that element appended to the end.
+  /// - Returns: A new ``FunctionParameterListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> FunctionParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `FunctionParameterListSyntax` by prepending the provided syntax element
+  /// Creates a new ``FunctionParameterListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `FunctionParameterListSyntax` with that element prepended to the
+  /// - Returns: A new ``FunctionParameterListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> FunctionParameterListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `FunctionParameterListSyntax` by inserting the provided syntax element
+  /// Creates a new ``FunctionParameterListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `FunctionParameterListSyntax` with that element appended to the end.
+  /// - Returns: A new ``FunctionParameterListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> FunctionParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -4960,14 +4960,14 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `FunctionParameterListSyntax` by replacing the syntax element
+  /// Creates a new ``FunctionParameterListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `FunctionParameterListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``FunctionParameterListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> FunctionParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -4977,11 +4977,11 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `FunctionParameterListSyntax` by removing the syntax element at the
+  /// Creates a new ``FunctionParameterListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `FunctionParameterListSyntax` with the element at the provided index
+  /// - Returns: A new ``FunctionParameterListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> FunctionParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -4989,18 +4989,18 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `FunctionParameterListSyntax` by removing the first element.
+  /// Creates a new ``FunctionParameterListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `FunctionParameterListSyntax` with the first element removed.
+  /// - Returns: A new ``FunctionParameterListSyntax`` with the first element removed.
   public func removingFirst() -> FunctionParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `FunctionParameterListSyntax` by removing the last element.
+  /// Creates a new ``FunctionParameterListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `FunctionParameterListSyntax` with the last element removed.
+  /// - Returns: A new ``FunctionParameterListSyntax`` with the last element removed.
   public func removingLast() -> FunctionParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -5008,7 +5008,7 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `FunctionParameterListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``FunctionParameterListSyntax`` to the `BidirectionalCollection` protocol.
 extension FunctionParameterListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -5074,8 +5074,8 @@ extension FunctionParameterListSyntax: BidirectionalCollection {
   }
 }
 
-/// `GenericArgumentListSyntax` represents a collection of one or more
-/// `GenericArgumentSyntax` nodes. GenericArgumentListSyntax behaves
+/// ``GenericArgumentListSyntax`` represents a collection of one or more
+/// ``GenericArgumentSyntax`` nodes. ``GenericArgumentListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable {
@@ -5118,12 +5118,12 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `GenericArgumentListSyntax` by replacing the underlying layout with
+  /// Creates a new ``GenericArgumentListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `GenericArgumentListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``GenericArgumentListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> GenericArgumentListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -5131,35 +5131,35 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable {
     return GenericArgumentListSyntax(newData)
   }
   
-  /// Creates a new `GenericArgumentListSyntax` by appending the provided syntax element
+  /// Creates a new ``GenericArgumentListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `GenericArgumentListSyntax` with that element appended to the end.
+  /// - Returns: A new ``GenericArgumentListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> GenericArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericArgumentListSyntax` by prepending the provided syntax element
+  /// Creates a new ``GenericArgumentListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `GenericArgumentListSyntax` with that element prepended to the
+  /// - Returns: A new ``GenericArgumentListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> GenericArgumentListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `GenericArgumentListSyntax` by inserting the provided syntax element
+  /// Creates a new ``GenericArgumentListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `GenericArgumentListSyntax` with that element appended to the end.
+  /// - Returns: A new ``GenericArgumentListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> GenericArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -5169,14 +5169,14 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericArgumentListSyntax` by replacing the syntax element
+  /// Creates a new ``GenericArgumentListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `GenericArgumentListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``GenericArgumentListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> GenericArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -5186,11 +5186,11 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericArgumentListSyntax` by removing the syntax element at the
+  /// Creates a new ``GenericArgumentListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `GenericArgumentListSyntax` with the element at the provided index
+  /// - Returns: A new ``GenericArgumentListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> GenericArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -5198,18 +5198,18 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericArgumentListSyntax` by removing the first element.
+  /// Creates a new ``GenericArgumentListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `GenericArgumentListSyntax` with the first element removed.
+  /// - Returns: A new ``GenericArgumentListSyntax`` with the first element removed.
   public func removingFirst() -> GenericArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericArgumentListSyntax` by removing the last element.
+  /// Creates a new ``GenericArgumentListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `GenericArgumentListSyntax` with the last element removed.
+  /// - Returns: A new ``GenericArgumentListSyntax`` with the last element removed.
   public func removingLast() -> GenericArgumentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -5217,7 +5217,7 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `GenericArgumentListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``GenericArgumentListSyntax`` to the `BidirectionalCollection` protocol.
 extension GenericArgumentListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -5283,8 +5283,8 @@ extension GenericArgumentListSyntax: BidirectionalCollection {
   }
 }
 
-/// `GenericParameterListSyntax` represents a collection of one or more
-/// `GenericParameterSyntax` nodes. GenericParameterListSyntax behaves
+/// ``GenericParameterListSyntax`` represents a collection of one or more
+/// ``GenericParameterSyntax`` nodes. ``GenericParameterListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable {
@@ -5327,12 +5327,12 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `GenericParameterListSyntax` by replacing the underlying layout with
+  /// Creates a new ``GenericParameterListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `GenericParameterListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``GenericParameterListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> GenericParameterListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -5340,35 +5340,35 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return GenericParameterListSyntax(newData)
   }
   
-  /// Creates a new `GenericParameterListSyntax` by appending the provided syntax element
+  /// Creates a new ``GenericParameterListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `GenericParameterListSyntax` with that element appended to the end.
+  /// - Returns: A new ``GenericParameterListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> GenericParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericParameterListSyntax` by prepending the provided syntax element
+  /// Creates a new ``GenericParameterListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `GenericParameterListSyntax` with that element prepended to the
+  /// - Returns: A new ``GenericParameterListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> GenericParameterListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `GenericParameterListSyntax` by inserting the provided syntax element
+  /// Creates a new ``GenericParameterListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `GenericParameterListSyntax` with that element appended to the end.
+  /// - Returns: A new ``GenericParameterListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> GenericParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -5378,14 +5378,14 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericParameterListSyntax` by replacing the syntax element
+  /// Creates a new ``GenericParameterListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `GenericParameterListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``GenericParameterListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> GenericParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -5395,11 +5395,11 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericParameterListSyntax` by removing the syntax element at the
+  /// Creates a new ``GenericParameterListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `GenericParameterListSyntax` with the element at the provided index
+  /// - Returns: A new ``GenericParameterListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> GenericParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -5407,18 +5407,18 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericParameterListSyntax` by removing the first element.
+  /// Creates a new ``GenericParameterListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `GenericParameterListSyntax` with the first element removed.
+  /// - Returns: A new ``GenericParameterListSyntax`` with the first element removed.
   public func removingFirst() -> GenericParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericParameterListSyntax` by removing the last element.
+  /// Creates a new ``GenericParameterListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `GenericParameterListSyntax` with the last element removed.
+  /// - Returns: A new ``GenericParameterListSyntax`` with the last element removed.
   public func removingLast() -> GenericParameterListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -5426,7 +5426,7 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `GenericParameterListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``GenericParameterListSyntax`` to the `BidirectionalCollection` protocol.
 extension GenericParameterListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -5492,8 +5492,8 @@ extension GenericParameterListSyntax: BidirectionalCollection {
   }
 }
 
-/// `GenericRequirementListSyntax` represents a collection of one or more
-/// `GenericRequirementSyntax` nodes. GenericRequirementListSyntax behaves
+/// ``GenericRequirementListSyntax`` represents a collection of one or more
+/// ``GenericRequirementSyntax`` nodes. ``GenericRequirementListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable {
@@ -5536,12 +5536,12 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `GenericRequirementListSyntax` by replacing the underlying layout with
+  /// Creates a new ``GenericRequirementListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `GenericRequirementListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``GenericRequirementListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> GenericRequirementListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -5549,35 +5549,35 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable {
     return GenericRequirementListSyntax(newData)
   }
   
-  /// Creates a new `GenericRequirementListSyntax` by appending the provided syntax element
+  /// Creates a new ``GenericRequirementListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `GenericRequirementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``GenericRequirementListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> GenericRequirementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericRequirementListSyntax` by prepending the provided syntax element
+  /// Creates a new ``GenericRequirementListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `GenericRequirementListSyntax` with that element prepended to the
+  /// - Returns: A new ``GenericRequirementListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> GenericRequirementListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `GenericRequirementListSyntax` by inserting the provided syntax element
+  /// Creates a new ``GenericRequirementListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `GenericRequirementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``GenericRequirementListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> GenericRequirementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -5587,14 +5587,14 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericRequirementListSyntax` by replacing the syntax element
+  /// Creates a new ``GenericRequirementListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `GenericRequirementListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``GenericRequirementListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> GenericRequirementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -5604,11 +5604,11 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericRequirementListSyntax` by removing the syntax element at the
+  /// Creates a new ``GenericRequirementListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `GenericRequirementListSyntax` with the element at the provided index
+  /// - Returns: A new ``GenericRequirementListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> GenericRequirementListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -5616,18 +5616,18 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericRequirementListSyntax` by removing the first element.
+  /// Creates a new ``GenericRequirementListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `GenericRequirementListSyntax` with the first element removed.
+  /// - Returns: A new ``GenericRequirementListSyntax`` with the first element removed.
   public func removingFirst() -> GenericRequirementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `GenericRequirementListSyntax` by removing the last element.
+  /// Creates a new ``GenericRequirementListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `GenericRequirementListSyntax` with the last element removed.
+  /// - Returns: A new ``GenericRequirementListSyntax`` with the last element removed.
   public func removingLast() -> GenericRequirementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -5635,7 +5635,7 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `GenericRequirementListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``GenericRequirementListSyntax`` to the `BidirectionalCollection` protocol.
 extension GenericRequirementListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -5701,8 +5701,8 @@ extension GenericRequirementListSyntax: BidirectionalCollection {
   }
 }
 
-/// `IfConfigClauseListSyntax` represents a collection of one or more
-/// `IfConfigClauseSyntax` nodes. IfConfigClauseListSyntax behaves
+/// ``IfConfigClauseListSyntax`` represents a collection of one or more
+/// ``IfConfigClauseSyntax`` nodes. ``IfConfigClauseListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable {
@@ -5745,12 +5745,12 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `IfConfigClauseListSyntax` by replacing the underlying layout with
+  /// Creates a new ``IfConfigClauseListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `IfConfigClauseListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``IfConfigClauseListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> IfConfigClauseListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -5758,35 +5758,35 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable {
     return IfConfigClauseListSyntax(newData)
   }
   
-  /// Creates a new `IfConfigClauseListSyntax` by appending the provided syntax element
+  /// Creates a new ``IfConfigClauseListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `IfConfigClauseListSyntax` with that element appended to the end.
+  /// - Returns: A new ``IfConfigClauseListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> IfConfigClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `IfConfigClauseListSyntax` by prepending the provided syntax element
+  /// Creates a new ``IfConfigClauseListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `IfConfigClauseListSyntax` with that element prepended to the
+  /// - Returns: A new ``IfConfigClauseListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> IfConfigClauseListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `IfConfigClauseListSyntax` by inserting the provided syntax element
+  /// Creates a new ``IfConfigClauseListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `IfConfigClauseListSyntax` with that element appended to the end.
+  /// - Returns: A new ``IfConfigClauseListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> IfConfigClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -5796,14 +5796,14 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `IfConfigClauseListSyntax` by replacing the syntax element
+  /// Creates a new ``IfConfigClauseListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `IfConfigClauseListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``IfConfigClauseListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> IfConfigClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -5813,11 +5813,11 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `IfConfigClauseListSyntax` by removing the syntax element at the
+  /// Creates a new ``IfConfigClauseListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `IfConfigClauseListSyntax` with the element at the provided index
+  /// - Returns: A new ``IfConfigClauseListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> IfConfigClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -5825,18 +5825,18 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `IfConfigClauseListSyntax` by removing the first element.
+  /// Creates a new ``IfConfigClauseListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `IfConfigClauseListSyntax` with the first element removed.
+  /// - Returns: A new ``IfConfigClauseListSyntax`` with the first element removed.
   public func removingFirst() -> IfConfigClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `IfConfigClauseListSyntax` by removing the last element.
+  /// Creates a new ``IfConfigClauseListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `IfConfigClauseListSyntax` with the last element removed.
+  /// - Returns: A new ``IfConfigClauseListSyntax`` with the last element removed.
   public func removingLast() -> IfConfigClauseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -5844,7 +5844,7 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `IfConfigClauseListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``IfConfigClauseListSyntax`` to the `BidirectionalCollection` protocol.
 extension IfConfigClauseListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -5910,8 +5910,8 @@ extension IfConfigClauseListSyntax: BidirectionalCollection {
   }
 }
 
-/// `ImportPathSyntax` represents a collection of one or more
-/// `ImportPathComponentSyntax` nodes. ImportPathSyntax behaves
+/// ``ImportPathSyntax`` represents a collection of one or more
+/// ``ImportPathComponentSyntax`` nodes. ``ImportPathSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct ImportPathSyntax: SyntaxCollection, SyntaxHashable {
@@ -5954,12 +5954,12 @@ public struct ImportPathSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `ImportPathSyntax` by replacing the underlying layout with
+  /// Creates a new ``ImportPathSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `ImportPathSyntax` with the new layout underlying it.
+  /// - Returns: A new ``ImportPathSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> ImportPathSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -5967,35 +5967,35 @@ public struct ImportPathSyntax: SyntaxCollection, SyntaxHashable {
     return ImportPathSyntax(newData)
   }
   
-  /// Creates a new `ImportPathSyntax` by appending the provided syntax element
+  /// Creates a new ``ImportPathSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `ImportPathSyntax` with that element appended to the end.
+  /// - Returns: A new ``ImportPathSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> ImportPathSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ImportPathSyntax` by prepending the provided syntax element
+  /// Creates a new ``ImportPathSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `ImportPathSyntax` with that element prepended to the
+  /// - Returns: A new ``ImportPathSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> ImportPathSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `ImportPathSyntax` by inserting the provided syntax element
+  /// Creates a new ``ImportPathSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `ImportPathSyntax` with that element appended to the end.
+  /// - Returns: A new ``ImportPathSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> ImportPathSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -6005,14 +6005,14 @@ public struct ImportPathSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ImportPathSyntax` by replacing the syntax element
+  /// Creates a new ``ImportPathSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `ImportPathSyntax` with the new element at the provided index.
+  /// - Returns: A new ``ImportPathSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> ImportPathSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -6022,11 +6022,11 @@ public struct ImportPathSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ImportPathSyntax` by removing the syntax element at the
+  /// Creates a new ``ImportPathSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `ImportPathSyntax` with the element at the provided index
+  /// - Returns: A new ``ImportPathSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> ImportPathSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -6034,18 +6034,18 @@ public struct ImportPathSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ImportPathSyntax` by removing the first element.
+  /// Creates a new ``ImportPathSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `ImportPathSyntax` with the first element removed.
+  /// - Returns: A new ``ImportPathSyntax`` with the first element removed.
   public func removingFirst() -> ImportPathSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ImportPathSyntax` by removing the last element.
+  /// Creates a new ``ImportPathSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `ImportPathSyntax` with the last element removed.
+  /// - Returns: A new ``ImportPathSyntax`` with the last element removed.
   public func removingLast() -> ImportPathSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -6053,7 +6053,7 @@ public struct ImportPathSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `ImportPathSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``ImportPathSyntax`` to the `BidirectionalCollection` protocol.
 extension ImportPathSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -6119,8 +6119,8 @@ extension ImportPathSyntax: BidirectionalCollection {
   }
 }
 
-/// `InheritedTypeListSyntax` represents a collection of one or more
-/// `InheritedTypeSyntax` nodes. InheritedTypeListSyntax behaves
+/// ``InheritedTypeListSyntax`` represents a collection of one or more
+/// ``InheritedTypeSyntax`` nodes. ``InheritedTypeListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable {
@@ -6163,12 +6163,12 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `InheritedTypeListSyntax` by replacing the underlying layout with
+  /// Creates a new ``InheritedTypeListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `InheritedTypeListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``InheritedTypeListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> InheritedTypeListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -6176,35 +6176,35 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable {
     return InheritedTypeListSyntax(newData)
   }
   
-  /// Creates a new `InheritedTypeListSyntax` by appending the provided syntax element
+  /// Creates a new ``InheritedTypeListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `InheritedTypeListSyntax` with that element appended to the end.
+  /// - Returns: A new ``InheritedTypeListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> InheritedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `InheritedTypeListSyntax` by prepending the provided syntax element
+  /// Creates a new ``InheritedTypeListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `InheritedTypeListSyntax` with that element prepended to the
+  /// - Returns: A new ``InheritedTypeListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> InheritedTypeListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `InheritedTypeListSyntax` by inserting the provided syntax element
+  /// Creates a new ``InheritedTypeListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `InheritedTypeListSyntax` with that element appended to the end.
+  /// - Returns: A new ``InheritedTypeListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> InheritedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -6214,14 +6214,14 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `InheritedTypeListSyntax` by replacing the syntax element
+  /// Creates a new ``InheritedTypeListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `InheritedTypeListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``InheritedTypeListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> InheritedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -6231,11 +6231,11 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `InheritedTypeListSyntax` by removing the syntax element at the
+  /// Creates a new ``InheritedTypeListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `InheritedTypeListSyntax` with the element at the provided index
+  /// - Returns: A new ``InheritedTypeListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> InheritedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -6243,18 +6243,18 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `InheritedTypeListSyntax` by removing the first element.
+  /// Creates a new ``InheritedTypeListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `InheritedTypeListSyntax` with the first element removed.
+  /// - Returns: A new ``InheritedTypeListSyntax`` with the first element removed.
   public func removingFirst() -> InheritedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `InheritedTypeListSyntax` by removing the last element.
+  /// Creates a new ``InheritedTypeListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `InheritedTypeListSyntax` with the last element removed.
+  /// - Returns: A new ``InheritedTypeListSyntax`` with the last element removed.
   public func removingLast() -> InheritedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -6262,7 +6262,7 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `InheritedTypeListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``InheritedTypeListSyntax`` to the `BidirectionalCollection` protocol.
 extension InheritedTypeListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -6328,8 +6328,8 @@ extension InheritedTypeListSyntax: BidirectionalCollection {
   }
 }
 
-/// `KeyPathComponentListSyntax` represents a collection of one or more
-/// `KeyPathComponentSyntax` nodes. KeyPathComponentListSyntax behaves
+/// ``KeyPathComponentListSyntax`` represents a collection of one or more
+/// ``KeyPathComponentSyntax`` nodes. ``KeyPathComponentListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable {
@@ -6372,12 +6372,12 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `KeyPathComponentListSyntax` by replacing the underlying layout with
+  /// Creates a new ``KeyPathComponentListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `KeyPathComponentListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``KeyPathComponentListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> KeyPathComponentListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -6385,35 +6385,35 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable {
     return KeyPathComponentListSyntax(newData)
   }
   
-  /// Creates a new `KeyPathComponentListSyntax` by appending the provided syntax element
+  /// Creates a new ``KeyPathComponentListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `KeyPathComponentListSyntax` with that element appended to the end.
+  /// - Returns: A new ``KeyPathComponentListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> KeyPathComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `KeyPathComponentListSyntax` by prepending the provided syntax element
+  /// Creates a new ``KeyPathComponentListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `KeyPathComponentListSyntax` with that element prepended to the
+  /// - Returns: A new ``KeyPathComponentListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> KeyPathComponentListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `KeyPathComponentListSyntax` by inserting the provided syntax element
+  /// Creates a new ``KeyPathComponentListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `KeyPathComponentListSyntax` with that element appended to the end.
+  /// - Returns: A new ``KeyPathComponentListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> KeyPathComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -6423,14 +6423,14 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `KeyPathComponentListSyntax` by replacing the syntax element
+  /// Creates a new ``KeyPathComponentListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `KeyPathComponentListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``KeyPathComponentListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> KeyPathComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -6440,11 +6440,11 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `KeyPathComponentListSyntax` by removing the syntax element at the
+  /// Creates a new ``KeyPathComponentListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `KeyPathComponentListSyntax` with the element at the provided index
+  /// - Returns: A new ``KeyPathComponentListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> KeyPathComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -6452,18 +6452,18 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `KeyPathComponentListSyntax` by removing the first element.
+  /// Creates a new ``KeyPathComponentListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `KeyPathComponentListSyntax` with the first element removed.
+  /// - Returns: A new ``KeyPathComponentListSyntax`` with the first element removed.
   public func removingFirst() -> KeyPathComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `KeyPathComponentListSyntax` by removing the last element.
+  /// Creates a new ``KeyPathComponentListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `KeyPathComponentListSyntax` with the last element removed.
+  /// - Returns: A new ``KeyPathComponentListSyntax`` with the last element removed.
   public func removingLast() -> KeyPathComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -6471,7 +6471,7 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `KeyPathComponentListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``KeyPathComponentListSyntax`` to the `BidirectionalCollection` protocol.
 extension KeyPathComponentListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -6537,8 +6537,8 @@ extension KeyPathComponentListSyntax: BidirectionalCollection {
   }
 }
 
-/// `MemberDeclListSyntax` represents a collection of one or more
-/// `MemberDeclListItemSyntax` nodes. MemberDeclListSyntax behaves
+/// ``MemberDeclListSyntax`` represents a collection of one or more
+/// ``MemberDeclListItemSyntax`` nodes. ``MemberDeclListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable {
@@ -6581,12 +6581,12 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `MemberDeclListSyntax` by replacing the underlying layout with
+  /// Creates a new ``MemberDeclListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `MemberDeclListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``MemberDeclListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> MemberDeclListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -6594,35 +6594,35 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable {
     return MemberDeclListSyntax(newData)
   }
   
-  /// Creates a new `MemberDeclListSyntax` by appending the provided syntax element
+  /// Creates a new ``MemberDeclListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `MemberDeclListSyntax` with that element appended to the end.
+  /// - Returns: A new ``MemberDeclListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> MemberDeclListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `MemberDeclListSyntax` by prepending the provided syntax element
+  /// Creates a new ``MemberDeclListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `MemberDeclListSyntax` with that element prepended to the
+  /// - Returns: A new ``MemberDeclListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> MemberDeclListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `MemberDeclListSyntax` by inserting the provided syntax element
+  /// Creates a new ``MemberDeclListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `MemberDeclListSyntax` with that element appended to the end.
+  /// - Returns: A new ``MemberDeclListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> MemberDeclListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -6632,14 +6632,14 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `MemberDeclListSyntax` by replacing the syntax element
+  /// Creates a new ``MemberDeclListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `MemberDeclListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``MemberDeclListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> MemberDeclListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -6649,11 +6649,11 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `MemberDeclListSyntax` by removing the syntax element at the
+  /// Creates a new ``MemberDeclListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `MemberDeclListSyntax` with the element at the provided index
+  /// - Returns: A new ``MemberDeclListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> MemberDeclListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -6661,18 +6661,18 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `MemberDeclListSyntax` by removing the first element.
+  /// Creates a new ``MemberDeclListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `MemberDeclListSyntax` with the first element removed.
+  /// - Returns: A new ``MemberDeclListSyntax`` with the first element removed.
   public func removingFirst() -> MemberDeclListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `MemberDeclListSyntax` by removing the last element.
+  /// Creates a new ``MemberDeclListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `MemberDeclListSyntax` with the last element removed.
+  /// - Returns: A new ``MemberDeclListSyntax`` with the last element removed.
   public func removingLast() -> MemberDeclListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -6680,7 +6680,7 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `MemberDeclListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``MemberDeclListSyntax`` to the `BidirectionalCollection` protocol.
 extension MemberDeclListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -6746,8 +6746,8 @@ extension MemberDeclListSyntax: BidirectionalCollection {
   }
 }
 
-/// `ModifierListSyntax` represents a collection of one or more
-/// `DeclModifierSyntax` nodes. ModifierListSyntax behaves
+/// ``ModifierListSyntax`` represents a collection of one or more
+/// ``DeclModifierSyntax`` nodes. ``ModifierListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable {
@@ -6790,12 +6790,12 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `ModifierListSyntax` by replacing the underlying layout with
+  /// Creates a new ``ModifierListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `ModifierListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``ModifierListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> ModifierListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -6803,35 +6803,35 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable {
     return ModifierListSyntax(newData)
   }
   
-  /// Creates a new `ModifierListSyntax` by appending the provided syntax element
+  /// Creates a new ``ModifierListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `ModifierListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ModifierListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> ModifierListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ModifierListSyntax` by prepending the provided syntax element
+  /// Creates a new ``ModifierListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `ModifierListSyntax` with that element prepended to the
+  /// - Returns: A new ``ModifierListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> ModifierListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `ModifierListSyntax` by inserting the provided syntax element
+  /// Creates a new ``ModifierListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `ModifierListSyntax` with that element appended to the end.
+  /// - Returns: A new ``ModifierListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> ModifierListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -6841,14 +6841,14 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ModifierListSyntax` by replacing the syntax element
+  /// Creates a new ``ModifierListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `ModifierListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``ModifierListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> ModifierListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -6858,11 +6858,11 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ModifierListSyntax` by removing the syntax element at the
+  /// Creates a new ``ModifierListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `ModifierListSyntax` with the element at the provided index
+  /// - Returns: A new ``ModifierListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> ModifierListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -6870,18 +6870,18 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ModifierListSyntax` by removing the first element.
+  /// Creates a new ``ModifierListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `ModifierListSyntax` with the first element removed.
+  /// - Returns: A new ``ModifierListSyntax`` with the first element removed.
   public func removingFirst() -> ModifierListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ModifierListSyntax` by removing the last element.
+  /// Creates a new ``ModifierListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `ModifierListSyntax` with the last element removed.
+  /// - Returns: A new ``ModifierListSyntax`` with the last element removed.
   public func removingLast() -> ModifierListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -6889,7 +6889,7 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `ModifierListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``ModifierListSyntax`` to the `BidirectionalCollection` protocol.
 extension ModifierListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -6955,8 +6955,8 @@ extension ModifierListSyntax: BidirectionalCollection {
   }
 }
 
-/// `MultipleTrailingClosureElementListSyntax` represents a collection of one or more
-/// `MultipleTrailingClosureElementSyntax` nodes. MultipleTrailingClosureElementListSyntax behaves
+/// ``MultipleTrailingClosureElementListSyntax`` represents a collection of one or more
+/// ``MultipleTrailingClosureElementSyntax`` nodes. ``MultipleTrailingClosureElementListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, SyntaxHashable {
@@ -6999,12 +6999,12 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax
     return layoutView.children.count
   }
   
-  /// Creates a new `MultipleTrailingClosureElementListSyntax` by replacing the underlying layout with
+  /// Creates a new ``MultipleTrailingClosureElementListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `MultipleTrailingClosureElementListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``MultipleTrailingClosureElementListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> MultipleTrailingClosureElementListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -7012,35 +7012,35 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax
     return MultipleTrailingClosureElementListSyntax(newData)
   }
   
-  /// Creates a new `MultipleTrailingClosureElementListSyntax` by appending the provided syntax element
+  /// Creates a new ``MultipleTrailingClosureElementListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `MultipleTrailingClosureElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``MultipleTrailingClosureElementListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> MultipleTrailingClosureElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `MultipleTrailingClosureElementListSyntax` by prepending the provided syntax element
+  /// Creates a new ``MultipleTrailingClosureElementListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `MultipleTrailingClosureElementListSyntax` with that element prepended to the
+  /// - Returns: A new ``MultipleTrailingClosureElementListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> MultipleTrailingClosureElementListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `MultipleTrailingClosureElementListSyntax` by inserting the provided syntax element
+  /// Creates a new ``MultipleTrailingClosureElementListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `MultipleTrailingClosureElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``MultipleTrailingClosureElementListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> MultipleTrailingClosureElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -7050,14 +7050,14 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `MultipleTrailingClosureElementListSyntax` by replacing the syntax element
+  /// Creates a new ``MultipleTrailingClosureElementListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `MultipleTrailingClosureElementListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``MultipleTrailingClosureElementListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> MultipleTrailingClosureElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -7067,11 +7067,11 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `MultipleTrailingClosureElementListSyntax` by removing the syntax element at the
+  /// Creates a new ``MultipleTrailingClosureElementListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `MultipleTrailingClosureElementListSyntax` with the element at the provided index
+  /// - Returns: A new ``MultipleTrailingClosureElementListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> MultipleTrailingClosureElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -7079,18 +7079,18 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `MultipleTrailingClosureElementListSyntax` by removing the first element.
+  /// Creates a new ``MultipleTrailingClosureElementListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `MultipleTrailingClosureElementListSyntax` with the first element removed.
+  /// - Returns: A new ``MultipleTrailingClosureElementListSyntax`` with the first element removed.
   public func removingFirst() -> MultipleTrailingClosureElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `MultipleTrailingClosureElementListSyntax` by removing the last element.
+  /// Creates a new ``MultipleTrailingClosureElementListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `MultipleTrailingClosureElementListSyntax` with the last element removed.
+  /// - Returns: A new ``MultipleTrailingClosureElementListSyntax`` with the last element removed.
   public func removingLast() -> MultipleTrailingClosureElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -7098,7 +7098,7 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax
   }
 }
 
-/// Conformance for `MultipleTrailingClosureElementListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``MultipleTrailingClosureElementListSyntax`` to the `BidirectionalCollection` protocol.
 extension MultipleTrailingClosureElementListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -7164,8 +7164,8 @@ extension MultipleTrailingClosureElementListSyntax: BidirectionalCollection {
   }
 }
 
-/// `ObjCSelectorSyntax` represents a collection of one or more
-/// `ObjCSelectorPieceSyntax` nodes. ObjCSelectorSyntax behaves
+/// ``ObjCSelectorSyntax`` represents a collection of one or more
+/// ``ObjCSelectorPieceSyntax`` nodes. ``ObjCSelectorSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable {
@@ -7208,12 +7208,12 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `ObjCSelectorSyntax` by replacing the underlying layout with
+  /// Creates a new ``ObjCSelectorSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `ObjCSelectorSyntax` with the new layout underlying it.
+  /// - Returns: A new ``ObjCSelectorSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> ObjCSelectorSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -7221,35 +7221,35 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable {
     return ObjCSelectorSyntax(newData)
   }
   
-  /// Creates a new `ObjCSelectorSyntax` by appending the provided syntax element
+  /// Creates a new ``ObjCSelectorSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `ObjCSelectorSyntax` with that element appended to the end.
+  /// - Returns: A new ``ObjCSelectorSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> ObjCSelectorSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ObjCSelectorSyntax` by prepending the provided syntax element
+  /// Creates a new ``ObjCSelectorSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `ObjCSelectorSyntax` with that element prepended to the
+  /// - Returns: A new ``ObjCSelectorSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> ObjCSelectorSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `ObjCSelectorSyntax` by inserting the provided syntax element
+  /// Creates a new ``ObjCSelectorSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `ObjCSelectorSyntax` with that element appended to the end.
+  /// - Returns: A new ``ObjCSelectorSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> ObjCSelectorSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -7259,14 +7259,14 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ObjCSelectorSyntax` by replacing the syntax element
+  /// Creates a new ``ObjCSelectorSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `ObjCSelectorSyntax` with the new element at the provided index.
+  /// - Returns: A new ``ObjCSelectorSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> ObjCSelectorSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -7276,11 +7276,11 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ObjCSelectorSyntax` by removing the syntax element at the
+  /// Creates a new ``ObjCSelectorSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `ObjCSelectorSyntax` with the element at the provided index
+  /// - Returns: A new ``ObjCSelectorSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> ObjCSelectorSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -7288,18 +7288,18 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ObjCSelectorSyntax` by removing the first element.
+  /// Creates a new ``ObjCSelectorSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `ObjCSelectorSyntax` with the first element removed.
+  /// - Returns: A new ``ObjCSelectorSyntax`` with the first element removed.
   public func removingFirst() -> ObjCSelectorSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `ObjCSelectorSyntax` by removing the last element.
+  /// Creates a new ``ObjCSelectorSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `ObjCSelectorSyntax` with the last element removed.
+  /// - Returns: A new ``ObjCSelectorSyntax`` with the last element removed.
   public func removingLast() -> ObjCSelectorSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -7307,7 +7307,7 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `ObjCSelectorSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``ObjCSelectorSyntax`` to the `BidirectionalCollection` protocol.
 extension ObjCSelectorSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -7373,8 +7373,8 @@ extension ObjCSelectorSyntax: BidirectionalCollection {
   }
 }
 
-/// `PatternBindingListSyntax` represents a collection of one or more
-/// `PatternBindingSyntax` nodes. PatternBindingListSyntax behaves
+/// ``PatternBindingListSyntax`` represents a collection of one or more
+/// ``PatternBindingSyntax`` nodes. ``PatternBindingListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable {
@@ -7417,12 +7417,12 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `PatternBindingListSyntax` by replacing the underlying layout with
+  /// Creates a new ``PatternBindingListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `PatternBindingListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``PatternBindingListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> PatternBindingListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -7430,35 +7430,35 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable {
     return PatternBindingListSyntax(newData)
   }
   
-  /// Creates a new `PatternBindingListSyntax` by appending the provided syntax element
+  /// Creates a new ``PatternBindingListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `PatternBindingListSyntax` with that element appended to the end.
+  /// - Returns: A new ``PatternBindingListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> PatternBindingListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PatternBindingListSyntax` by prepending the provided syntax element
+  /// Creates a new ``PatternBindingListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `PatternBindingListSyntax` with that element prepended to the
+  /// - Returns: A new ``PatternBindingListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> PatternBindingListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `PatternBindingListSyntax` by inserting the provided syntax element
+  /// Creates a new ``PatternBindingListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `PatternBindingListSyntax` with that element appended to the end.
+  /// - Returns: A new ``PatternBindingListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> PatternBindingListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -7468,14 +7468,14 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PatternBindingListSyntax` by replacing the syntax element
+  /// Creates a new ``PatternBindingListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `PatternBindingListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``PatternBindingListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> PatternBindingListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -7485,11 +7485,11 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PatternBindingListSyntax` by removing the syntax element at the
+  /// Creates a new ``PatternBindingListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `PatternBindingListSyntax` with the element at the provided index
+  /// - Returns: A new ``PatternBindingListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> PatternBindingListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -7497,18 +7497,18 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PatternBindingListSyntax` by removing the first element.
+  /// Creates a new ``PatternBindingListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `PatternBindingListSyntax` with the first element removed.
+  /// - Returns: A new ``PatternBindingListSyntax`` with the first element removed.
   public func removingFirst() -> PatternBindingListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PatternBindingListSyntax` by removing the last element.
+  /// Creates a new ``PatternBindingListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `PatternBindingListSyntax` with the last element removed.
+  /// - Returns: A new ``PatternBindingListSyntax`` with the last element removed.
   public func removingLast() -> PatternBindingListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -7516,7 +7516,7 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `PatternBindingListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``PatternBindingListSyntax`` to the `BidirectionalCollection` protocol.
 extension PatternBindingListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -7582,8 +7582,8 @@ extension PatternBindingListSyntax: BidirectionalCollection {
   }
 }
 
-/// `PrecedenceGroupAttributeListSyntax` represents a collection of one or more
-/// `Syntax` nodes. PrecedenceGroupAttributeListSyntax behaves
+/// ``PrecedenceGroupAttributeListSyntax`` represents a collection of one or more
+/// ``Syntax`` nodes. ``PrecedenceGroupAttributeListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashable {
@@ -7680,12 +7680,12 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab
     return layoutView.children.count
   }
   
-  /// Creates a new `PrecedenceGroupAttributeListSyntax` by replacing the underlying layout with
+  /// Creates a new ``PrecedenceGroupAttributeListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `PrecedenceGroupAttributeListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``PrecedenceGroupAttributeListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> PrecedenceGroupAttributeListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -7693,35 +7693,35 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab
     return PrecedenceGroupAttributeListSyntax(newData)
   }
   
-  /// Creates a new `PrecedenceGroupAttributeListSyntax` by appending the provided syntax element
+  /// Creates a new ``PrecedenceGroupAttributeListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `PrecedenceGroupAttributeListSyntax` with that element appended to the end.
+  /// - Returns: A new ``PrecedenceGroupAttributeListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> PrecedenceGroupAttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrecedenceGroupAttributeListSyntax` by prepending the provided syntax element
+  /// Creates a new ``PrecedenceGroupAttributeListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `PrecedenceGroupAttributeListSyntax` with that element prepended to the
+  /// - Returns: A new ``PrecedenceGroupAttributeListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> PrecedenceGroupAttributeListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `PrecedenceGroupAttributeListSyntax` by inserting the provided syntax element
+  /// Creates a new ``PrecedenceGroupAttributeListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `PrecedenceGroupAttributeListSyntax` with that element appended to the end.
+  /// - Returns: A new ``PrecedenceGroupAttributeListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> PrecedenceGroupAttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -7731,14 +7731,14 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrecedenceGroupAttributeListSyntax` by replacing the syntax element
+  /// Creates a new ``PrecedenceGroupAttributeListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `PrecedenceGroupAttributeListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``PrecedenceGroupAttributeListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> PrecedenceGroupAttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -7748,11 +7748,11 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrecedenceGroupAttributeListSyntax` by removing the syntax element at the
+  /// Creates a new ``PrecedenceGroupAttributeListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `PrecedenceGroupAttributeListSyntax` with the element at the provided index
+  /// - Returns: A new ``PrecedenceGroupAttributeListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> PrecedenceGroupAttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -7760,18 +7760,18 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrecedenceGroupAttributeListSyntax` by removing the first element.
+  /// Creates a new ``PrecedenceGroupAttributeListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `PrecedenceGroupAttributeListSyntax` with the first element removed.
+  /// - Returns: A new ``PrecedenceGroupAttributeListSyntax`` with the first element removed.
   public func removingFirst() -> PrecedenceGroupAttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrecedenceGroupAttributeListSyntax` by removing the last element.
+  /// Creates a new ``PrecedenceGroupAttributeListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `PrecedenceGroupAttributeListSyntax` with the last element removed.
+  /// - Returns: A new ``PrecedenceGroupAttributeListSyntax`` with the last element removed.
   public func removingLast() -> PrecedenceGroupAttributeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -7779,7 +7779,7 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab
   }
 }
 
-/// Conformance for `PrecedenceGroupAttributeListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``PrecedenceGroupAttributeListSyntax`` to the `BidirectionalCollection` protocol.
 extension PrecedenceGroupAttributeListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -7845,8 +7845,8 @@ extension PrecedenceGroupAttributeListSyntax: BidirectionalCollection {
   }
 }
 
-/// `PrecedenceGroupNameListSyntax` represents a collection of one or more
-/// `PrecedenceGroupNameElementSyntax` nodes. PrecedenceGroupNameListSyntax behaves
+/// ``PrecedenceGroupNameListSyntax`` represents a collection of one or more
+/// ``PrecedenceGroupNameElementSyntax`` nodes. ``PrecedenceGroupNameListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable {
@@ -7889,12 +7889,12 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `PrecedenceGroupNameListSyntax` by replacing the underlying layout with
+  /// Creates a new ``PrecedenceGroupNameListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `PrecedenceGroupNameListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``PrecedenceGroupNameListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> PrecedenceGroupNameListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -7902,35 +7902,35 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable {
     return PrecedenceGroupNameListSyntax(newData)
   }
   
-  /// Creates a new `PrecedenceGroupNameListSyntax` by appending the provided syntax element
+  /// Creates a new ``PrecedenceGroupNameListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `PrecedenceGroupNameListSyntax` with that element appended to the end.
+  /// - Returns: A new ``PrecedenceGroupNameListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> PrecedenceGroupNameListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrecedenceGroupNameListSyntax` by prepending the provided syntax element
+  /// Creates a new ``PrecedenceGroupNameListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `PrecedenceGroupNameListSyntax` with that element prepended to the
+  /// - Returns: A new ``PrecedenceGroupNameListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> PrecedenceGroupNameListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `PrecedenceGroupNameListSyntax` by inserting the provided syntax element
+  /// Creates a new ``PrecedenceGroupNameListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `PrecedenceGroupNameListSyntax` with that element appended to the end.
+  /// - Returns: A new ``PrecedenceGroupNameListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> PrecedenceGroupNameListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -7940,14 +7940,14 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrecedenceGroupNameListSyntax` by replacing the syntax element
+  /// Creates a new ``PrecedenceGroupNameListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `PrecedenceGroupNameListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``PrecedenceGroupNameListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> PrecedenceGroupNameListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -7957,11 +7957,11 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrecedenceGroupNameListSyntax` by removing the syntax element at the
+  /// Creates a new ``PrecedenceGroupNameListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `PrecedenceGroupNameListSyntax` with the element at the provided index
+  /// - Returns: A new ``PrecedenceGroupNameListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> PrecedenceGroupNameListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -7969,18 +7969,18 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrecedenceGroupNameListSyntax` by removing the first element.
+  /// Creates a new ``PrecedenceGroupNameListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `PrecedenceGroupNameListSyntax` with the first element removed.
+  /// - Returns: A new ``PrecedenceGroupNameListSyntax`` with the first element removed.
   public func removingFirst() -> PrecedenceGroupNameListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrecedenceGroupNameListSyntax` by removing the last element.
+  /// Creates a new ``PrecedenceGroupNameListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `PrecedenceGroupNameListSyntax` with the last element removed.
+  /// - Returns: A new ``PrecedenceGroupNameListSyntax`` with the last element removed.
   public func removingLast() -> PrecedenceGroupNameListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -7988,7 +7988,7 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `PrecedenceGroupNameListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``PrecedenceGroupNameListSyntax`` to the `BidirectionalCollection` protocol.
 extension PrecedenceGroupNameListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -8054,8 +8054,8 @@ extension PrecedenceGroupNameListSyntax: BidirectionalCollection {
   }
 }
 
-/// `PrimaryAssociatedTypeListSyntax` represents a collection of one or more
-/// `PrimaryAssociatedTypeSyntax` nodes. PrimaryAssociatedTypeListSyntax behaves
+/// ``PrimaryAssociatedTypeListSyntax`` represents a collection of one or more
+/// ``PrimaryAssociatedTypeSyntax`` nodes. ``PrimaryAssociatedTypeListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable {
@@ -8098,12 +8098,12 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable
     return layoutView.children.count
   }
   
-  /// Creates a new `PrimaryAssociatedTypeListSyntax` by replacing the underlying layout with
+  /// Creates a new ``PrimaryAssociatedTypeListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `PrimaryAssociatedTypeListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``PrimaryAssociatedTypeListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> PrimaryAssociatedTypeListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -8111,35 +8111,35 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable
     return PrimaryAssociatedTypeListSyntax(newData)
   }
   
-  /// Creates a new `PrimaryAssociatedTypeListSyntax` by appending the provided syntax element
+  /// Creates a new ``PrimaryAssociatedTypeListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `PrimaryAssociatedTypeListSyntax` with that element appended to the end.
+  /// - Returns: A new ``PrimaryAssociatedTypeListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> PrimaryAssociatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrimaryAssociatedTypeListSyntax` by prepending the provided syntax element
+  /// Creates a new ``PrimaryAssociatedTypeListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `PrimaryAssociatedTypeListSyntax` with that element prepended to the
+  /// - Returns: A new ``PrimaryAssociatedTypeListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> PrimaryAssociatedTypeListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `PrimaryAssociatedTypeListSyntax` by inserting the provided syntax element
+  /// Creates a new ``PrimaryAssociatedTypeListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `PrimaryAssociatedTypeListSyntax` with that element appended to the end.
+  /// - Returns: A new ``PrimaryAssociatedTypeListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> PrimaryAssociatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -8149,14 +8149,14 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrimaryAssociatedTypeListSyntax` by replacing the syntax element
+  /// Creates a new ``PrimaryAssociatedTypeListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `PrimaryAssociatedTypeListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``PrimaryAssociatedTypeListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> PrimaryAssociatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -8166,11 +8166,11 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrimaryAssociatedTypeListSyntax` by removing the syntax element at the
+  /// Creates a new ``PrimaryAssociatedTypeListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `PrimaryAssociatedTypeListSyntax` with the element at the provided index
+  /// - Returns: A new ``PrimaryAssociatedTypeListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> PrimaryAssociatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -8178,18 +8178,18 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrimaryAssociatedTypeListSyntax` by removing the first element.
+  /// Creates a new ``PrimaryAssociatedTypeListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `PrimaryAssociatedTypeListSyntax` with the first element removed.
+  /// - Returns: A new ``PrimaryAssociatedTypeListSyntax`` with the first element removed.
   public func removingFirst() -> PrimaryAssociatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `PrimaryAssociatedTypeListSyntax` by removing the last element.
+  /// Creates a new ``PrimaryAssociatedTypeListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `PrimaryAssociatedTypeListSyntax` with the last element removed.
+  /// - Returns: A new ``PrimaryAssociatedTypeListSyntax`` with the last element removed.
   public func removingLast() -> PrimaryAssociatedTypeListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -8197,7 +8197,7 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable
   }
 }
 
-/// Conformance for `PrimaryAssociatedTypeListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``PrimaryAssociatedTypeListSyntax`` to the `BidirectionalCollection` protocol.
 extension PrimaryAssociatedTypeListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -8371,12 +8371,12 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl
     return layoutView.children.count
   }
   
-  /// Creates a new `SpecializeAttributeSpecListSyntax` by replacing the underlying layout with
+  /// Creates a new ``SpecializeAttributeSpecListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `SpecializeAttributeSpecListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``SpecializeAttributeSpecListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> SpecializeAttributeSpecListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -8384,35 +8384,35 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl
     return SpecializeAttributeSpecListSyntax(newData)
   }
   
-  /// Creates a new `SpecializeAttributeSpecListSyntax` by appending the provided syntax element
+  /// Creates a new ``SpecializeAttributeSpecListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `SpecializeAttributeSpecListSyntax` with that element appended to the end.
+  /// - Returns: A new ``SpecializeAttributeSpecListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> SpecializeAttributeSpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `SpecializeAttributeSpecListSyntax` by prepending the provided syntax element
+  /// Creates a new ``SpecializeAttributeSpecListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `SpecializeAttributeSpecListSyntax` with that element prepended to the
+  /// - Returns: A new ``SpecializeAttributeSpecListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> SpecializeAttributeSpecListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `SpecializeAttributeSpecListSyntax` by inserting the provided syntax element
+  /// Creates a new ``SpecializeAttributeSpecListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `SpecializeAttributeSpecListSyntax` with that element appended to the end.
+  /// - Returns: A new ``SpecializeAttributeSpecListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> SpecializeAttributeSpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -8422,14 +8422,14 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `SpecializeAttributeSpecListSyntax` by replacing the syntax element
+  /// Creates a new ``SpecializeAttributeSpecListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `SpecializeAttributeSpecListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``SpecializeAttributeSpecListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> SpecializeAttributeSpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -8439,11 +8439,11 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `SpecializeAttributeSpecListSyntax` by removing the syntax element at the
+  /// Creates a new ``SpecializeAttributeSpecListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `SpecializeAttributeSpecListSyntax` with the element at the provided index
+  /// - Returns: A new ``SpecializeAttributeSpecListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> SpecializeAttributeSpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -8451,18 +8451,18 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `SpecializeAttributeSpecListSyntax` by removing the first element.
+  /// Creates a new ``SpecializeAttributeSpecListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `SpecializeAttributeSpecListSyntax` with the first element removed.
+  /// - Returns: A new ``SpecializeAttributeSpecListSyntax`` with the first element removed.
   public func removingFirst() -> SpecializeAttributeSpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `SpecializeAttributeSpecListSyntax` by removing the last element.
+  /// Creates a new ``SpecializeAttributeSpecListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `SpecializeAttributeSpecListSyntax` with the last element removed.
+  /// - Returns: A new ``SpecializeAttributeSpecListSyntax`` with the last element removed.
   public func removingLast() -> SpecializeAttributeSpecListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -8470,7 +8470,7 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl
   }
 }
 
-/// Conformance for `SpecializeAttributeSpecListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``SpecializeAttributeSpecListSyntax`` to the `BidirectionalCollection` protocol.
 extension SpecializeAttributeSpecListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -8536,8 +8536,8 @@ extension SpecializeAttributeSpecListSyntax: BidirectionalCollection {
   }
 }
 
-/// `StringLiteralSegmentsSyntax` represents a collection of one or more
-/// `Syntax` nodes. StringLiteralSegmentsSyntax behaves
+/// ``StringLiteralSegmentsSyntax`` represents a collection of one or more
+/// ``Syntax`` nodes. ``StringLiteralSegmentsSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable {
@@ -8622,12 +8622,12 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `StringLiteralSegmentsSyntax` by replacing the underlying layout with
+  /// Creates a new ``StringLiteralSegmentsSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `StringLiteralSegmentsSyntax` with the new layout underlying it.
+  /// - Returns: A new ``StringLiteralSegmentsSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> StringLiteralSegmentsSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -8635,35 +8635,35 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable {
     return StringLiteralSegmentsSyntax(newData)
   }
   
-  /// Creates a new `StringLiteralSegmentsSyntax` by appending the provided syntax element
+  /// Creates a new ``StringLiteralSegmentsSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `StringLiteralSegmentsSyntax` with that element appended to the end.
+  /// - Returns: A new ``StringLiteralSegmentsSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> StringLiteralSegmentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `StringLiteralSegmentsSyntax` by prepending the provided syntax element
+  /// Creates a new ``StringLiteralSegmentsSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `StringLiteralSegmentsSyntax` with that element prepended to the
+  /// - Returns: A new ``StringLiteralSegmentsSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> StringLiteralSegmentsSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `StringLiteralSegmentsSyntax` by inserting the provided syntax element
+  /// Creates a new ``StringLiteralSegmentsSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `StringLiteralSegmentsSyntax` with that element appended to the end.
+  /// - Returns: A new ``StringLiteralSegmentsSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> StringLiteralSegmentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -8673,14 +8673,14 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `StringLiteralSegmentsSyntax` by replacing the syntax element
+  /// Creates a new ``StringLiteralSegmentsSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `StringLiteralSegmentsSyntax` with the new element at the provided index.
+  /// - Returns: A new ``StringLiteralSegmentsSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> StringLiteralSegmentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -8690,11 +8690,11 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `StringLiteralSegmentsSyntax` by removing the syntax element at the
+  /// Creates a new ``StringLiteralSegmentsSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `StringLiteralSegmentsSyntax` with the element at the provided index
+  /// - Returns: A new ``StringLiteralSegmentsSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> StringLiteralSegmentsSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -8702,18 +8702,18 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `StringLiteralSegmentsSyntax` by removing the first element.
+  /// Creates a new ``StringLiteralSegmentsSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `StringLiteralSegmentsSyntax` with the first element removed.
+  /// - Returns: A new ``StringLiteralSegmentsSyntax`` with the first element removed.
   public func removingFirst() -> StringLiteralSegmentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `StringLiteralSegmentsSyntax` by removing the last element.
+  /// Creates a new ``StringLiteralSegmentsSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `StringLiteralSegmentsSyntax` with the last element removed.
+  /// - Returns: A new ``StringLiteralSegmentsSyntax`` with the last element removed.
   public func removingLast() -> StringLiteralSegmentsSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -8721,7 +8721,7 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `StringLiteralSegmentsSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``StringLiteralSegmentsSyntax`` to the `BidirectionalCollection` protocol.
 extension StringLiteralSegmentsSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -8787,8 +8787,8 @@ extension StringLiteralSegmentsSyntax: BidirectionalCollection {
   }
 }
 
-/// `SwitchCaseListSyntax` represents a collection of one or more
-/// `Syntax` nodes. SwitchCaseListSyntax behaves
+/// ``SwitchCaseListSyntax`` represents a collection of one or more
+/// ``Syntax`` nodes. ``SwitchCaseListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable {
@@ -8873,12 +8873,12 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `SwitchCaseListSyntax` by replacing the underlying layout with
+  /// Creates a new ``SwitchCaseListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `SwitchCaseListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``SwitchCaseListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> SwitchCaseListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -8886,35 +8886,35 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable {
     return SwitchCaseListSyntax(newData)
   }
   
-  /// Creates a new `SwitchCaseListSyntax` by appending the provided syntax element
+  /// Creates a new ``SwitchCaseListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `SwitchCaseListSyntax` with that element appended to the end.
+  /// - Returns: A new ``SwitchCaseListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> SwitchCaseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `SwitchCaseListSyntax` by prepending the provided syntax element
+  /// Creates a new ``SwitchCaseListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `SwitchCaseListSyntax` with that element prepended to the
+  /// - Returns: A new ``SwitchCaseListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> SwitchCaseListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `SwitchCaseListSyntax` by inserting the provided syntax element
+  /// Creates a new ``SwitchCaseListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `SwitchCaseListSyntax` with that element appended to the end.
+  /// - Returns: A new ``SwitchCaseListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> SwitchCaseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -8924,14 +8924,14 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `SwitchCaseListSyntax` by replacing the syntax element
+  /// Creates a new ``SwitchCaseListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `SwitchCaseListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``SwitchCaseListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> SwitchCaseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -8941,11 +8941,11 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `SwitchCaseListSyntax` by removing the syntax element at the
+  /// Creates a new ``SwitchCaseListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `SwitchCaseListSyntax` with the element at the provided index
+  /// - Returns: A new ``SwitchCaseListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> SwitchCaseListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -8953,18 +8953,18 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `SwitchCaseListSyntax` by removing the first element.
+  /// Creates a new ``SwitchCaseListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `SwitchCaseListSyntax` with the first element removed.
+  /// - Returns: A new ``SwitchCaseListSyntax`` with the first element removed.
   public func removingFirst() -> SwitchCaseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `SwitchCaseListSyntax` by removing the last element.
+  /// Creates a new ``SwitchCaseListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `SwitchCaseListSyntax` with the last element removed.
+  /// - Returns: A new ``SwitchCaseListSyntax`` with the last element removed.
   public func removingLast() -> SwitchCaseListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -8972,7 +8972,7 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `SwitchCaseListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``SwitchCaseListSyntax`` to the `BidirectionalCollection` protocol.
 extension SwitchCaseListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -9038,8 +9038,8 @@ extension SwitchCaseListSyntax: BidirectionalCollection {
   }
 }
 
-/// `TupleExprElementListSyntax` represents a collection of one or more
-/// `TupleExprElementSyntax` nodes. TupleExprElementListSyntax behaves
+/// ``TupleExprElementListSyntax`` represents a collection of one or more
+/// ``TupleExprElementSyntax`` nodes. ``TupleExprElementListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable {
@@ -9082,12 +9082,12 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `TupleExprElementListSyntax` by replacing the underlying layout with
+  /// Creates a new ``TupleExprElementListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `TupleExprElementListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``TupleExprElementListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> TupleExprElementListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -9095,35 +9095,35 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable {
     return TupleExprElementListSyntax(newData)
   }
   
-  /// Creates a new `TupleExprElementListSyntax` by appending the provided syntax element
+  /// Creates a new ``TupleExprElementListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `TupleExprElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``TupleExprElementListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> TupleExprElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TupleExprElementListSyntax` by prepending the provided syntax element
+  /// Creates a new ``TupleExprElementListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `TupleExprElementListSyntax` with that element prepended to the
+  /// - Returns: A new ``TupleExprElementListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> TupleExprElementListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `TupleExprElementListSyntax` by inserting the provided syntax element
+  /// Creates a new ``TupleExprElementListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `TupleExprElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``TupleExprElementListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> TupleExprElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -9133,14 +9133,14 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TupleExprElementListSyntax` by replacing the syntax element
+  /// Creates a new ``TupleExprElementListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `TupleExprElementListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``TupleExprElementListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> TupleExprElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -9150,11 +9150,11 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TupleExprElementListSyntax` by removing the syntax element at the
+  /// Creates a new ``TupleExprElementListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `TupleExprElementListSyntax` with the element at the provided index
+  /// - Returns: A new ``TupleExprElementListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> TupleExprElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -9162,18 +9162,18 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TupleExprElementListSyntax` by removing the first element.
+  /// Creates a new ``TupleExprElementListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `TupleExprElementListSyntax` with the first element removed.
+  /// - Returns: A new ``TupleExprElementListSyntax`` with the first element removed.
   public func removingFirst() -> TupleExprElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TupleExprElementListSyntax` by removing the last element.
+  /// Creates a new ``TupleExprElementListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `TupleExprElementListSyntax` with the last element removed.
+  /// - Returns: A new ``TupleExprElementListSyntax`` with the last element removed.
   public func removingLast() -> TupleExprElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -9181,7 +9181,7 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `TupleExprElementListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``TupleExprElementListSyntax`` to the `BidirectionalCollection` protocol.
 extension TupleExprElementListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -9247,8 +9247,8 @@ extension TupleExprElementListSyntax: BidirectionalCollection {
   }
 }
 
-/// `TuplePatternElementListSyntax` represents a collection of one or more
-/// `TuplePatternElementSyntax` nodes. TuplePatternElementListSyntax behaves
+/// ``TuplePatternElementListSyntax`` represents a collection of one or more
+/// ``TuplePatternElementSyntax`` nodes. ``TuplePatternElementListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable {
@@ -9291,12 +9291,12 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `TuplePatternElementListSyntax` by replacing the underlying layout with
+  /// Creates a new ``TuplePatternElementListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `TuplePatternElementListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``TuplePatternElementListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> TuplePatternElementListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -9304,35 +9304,35 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable {
     return TuplePatternElementListSyntax(newData)
   }
   
-  /// Creates a new `TuplePatternElementListSyntax` by appending the provided syntax element
+  /// Creates a new ``TuplePatternElementListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `TuplePatternElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``TuplePatternElementListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> TuplePatternElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TuplePatternElementListSyntax` by prepending the provided syntax element
+  /// Creates a new ``TuplePatternElementListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `TuplePatternElementListSyntax` with that element prepended to the
+  /// - Returns: A new ``TuplePatternElementListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> TuplePatternElementListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `TuplePatternElementListSyntax` by inserting the provided syntax element
+  /// Creates a new ``TuplePatternElementListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `TuplePatternElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``TuplePatternElementListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> TuplePatternElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -9342,14 +9342,14 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TuplePatternElementListSyntax` by replacing the syntax element
+  /// Creates a new ``TuplePatternElementListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `TuplePatternElementListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``TuplePatternElementListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> TuplePatternElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -9359,11 +9359,11 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TuplePatternElementListSyntax` by removing the syntax element at the
+  /// Creates a new ``TuplePatternElementListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `TuplePatternElementListSyntax` with the element at the provided index
+  /// - Returns: A new ``TuplePatternElementListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> TuplePatternElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -9371,18 +9371,18 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TuplePatternElementListSyntax` by removing the first element.
+  /// Creates a new ``TuplePatternElementListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `TuplePatternElementListSyntax` with the first element removed.
+  /// - Returns: A new ``TuplePatternElementListSyntax`` with the first element removed.
   public func removingFirst() -> TuplePatternElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TuplePatternElementListSyntax` by removing the last element.
+  /// Creates a new ``TuplePatternElementListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `TuplePatternElementListSyntax` with the last element removed.
+  /// - Returns: A new ``TuplePatternElementListSyntax`` with the last element removed.
   public func removingLast() -> TuplePatternElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -9390,7 +9390,7 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `TuplePatternElementListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``TuplePatternElementListSyntax`` to the `BidirectionalCollection` protocol.
 extension TuplePatternElementListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -9456,8 +9456,8 @@ extension TuplePatternElementListSyntax: BidirectionalCollection {
   }
 }
 
-/// `TupleTypeElementListSyntax` represents a collection of one or more
-/// `TupleTypeElementSyntax` nodes. TupleTypeElementListSyntax behaves
+/// ``TupleTypeElementListSyntax`` represents a collection of one or more
+/// ``TupleTypeElementSyntax`` nodes. ``TupleTypeElementListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable {
@@ -9500,12 +9500,12 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `TupleTypeElementListSyntax` by replacing the underlying layout with
+  /// Creates a new ``TupleTypeElementListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `TupleTypeElementListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``TupleTypeElementListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> TupleTypeElementListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -9513,35 +9513,35 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable {
     return TupleTypeElementListSyntax(newData)
   }
   
-  /// Creates a new `TupleTypeElementListSyntax` by appending the provided syntax element
+  /// Creates a new ``TupleTypeElementListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `TupleTypeElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``TupleTypeElementListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> TupleTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TupleTypeElementListSyntax` by prepending the provided syntax element
+  /// Creates a new ``TupleTypeElementListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `TupleTypeElementListSyntax` with that element prepended to the
+  /// - Returns: A new ``TupleTypeElementListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> TupleTypeElementListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `TupleTypeElementListSyntax` by inserting the provided syntax element
+  /// Creates a new ``TupleTypeElementListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `TupleTypeElementListSyntax` with that element appended to the end.
+  /// - Returns: A new ``TupleTypeElementListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> TupleTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -9551,14 +9551,14 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TupleTypeElementListSyntax` by replacing the syntax element
+  /// Creates a new ``TupleTypeElementListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `TupleTypeElementListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``TupleTypeElementListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> TupleTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -9568,11 +9568,11 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TupleTypeElementListSyntax` by removing the syntax element at the
+  /// Creates a new ``TupleTypeElementListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `TupleTypeElementListSyntax` with the element at the provided index
+  /// - Returns: A new ``TupleTypeElementListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> TupleTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -9580,18 +9580,18 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TupleTypeElementListSyntax` by removing the first element.
+  /// Creates a new ``TupleTypeElementListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `TupleTypeElementListSyntax` with the first element removed.
+  /// - Returns: A new ``TupleTypeElementListSyntax`` with the first element removed.
   public func removingFirst() -> TupleTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `TupleTypeElementListSyntax` by removing the last element.
+  /// Creates a new ``TupleTypeElementListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `TupleTypeElementListSyntax` with the last element removed.
+  /// - Returns: A new ``TupleTypeElementListSyntax`` with the last element removed.
   public func removingLast() -> TupleTypeElementListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -9599,7 +9599,7 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `TupleTypeElementListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``TupleTypeElementListSyntax`` to the `BidirectionalCollection` protocol.
 extension TupleTypeElementListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -9706,12 +9706,12 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `UnexpectedNodesSyntax` by replacing the underlying layout with
+  /// Creates a new ``UnexpectedNodesSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `UnexpectedNodesSyntax` with the new layout underlying it.
+  /// - Returns: A new ``UnexpectedNodesSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> UnexpectedNodesSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -9719,35 +9719,35 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable {
     return UnexpectedNodesSyntax(newData)
   }
   
-  /// Creates a new `UnexpectedNodesSyntax` by appending the provided syntax element
+  /// Creates a new ``UnexpectedNodesSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `UnexpectedNodesSyntax` with that element appended to the end.
+  /// - Returns: A new ``UnexpectedNodesSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> UnexpectedNodesSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `UnexpectedNodesSyntax` by prepending the provided syntax element
+  /// Creates a new ``UnexpectedNodesSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `UnexpectedNodesSyntax` with that element prepended to the
+  /// - Returns: A new ``UnexpectedNodesSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> UnexpectedNodesSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `UnexpectedNodesSyntax` by inserting the provided syntax element
+  /// Creates a new ``UnexpectedNodesSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `UnexpectedNodesSyntax` with that element appended to the end.
+  /// - Returns: A new ``UnexpectedNodesSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> UnexpectedNodesSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -9757,14 +9757,14 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `UnexpectedNodesSyntax` by replacing the syntax element
+  /// Creates a new ``UnexpectedNodesSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `UnexpectedNodesSyntax` with the new element at the provided index.
+  /// - Returns: A new ``UnexpectedNodesSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> UnexpectedNodesSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -9774,11 +9774,11 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `UnexpectedNodesSyntax` by removing the syntax element at the
+  /// Creates a new ``UnexpectedNodesSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `UnexpectedNodesSyntax` with the element at the provided index
+  /// - Returns: A new ``UnexpectedNodesSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> UnexpectedNodesSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -9786,18 +9786,18 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `UnexpectedNodesSyntax` by removing the first element.
+  /// Creates a new ``UnexpectedNodesSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `UnexpectedNodesSyntax` with the first element removed.
+  /// - Returns: A new ``UnexpectedNodesSyntax`` with the first element removed.
   public func removingFirst() -> UnexpectedNodesSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `UnexpectedNodesSyntax` by removing the last element.
+  /// Creates a new ``UnexpectedNodesSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `UnexpectedNodesSyntax` with the last element removed.
+  /// - Returns: A new ``UnexpectedNodesSyntax`` with the last element removed.
   public func removingLast() -> UnexpectedNodesSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -9805,7 +9805,7 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `UnexpectedNodesSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``UnexpectedNodesSyntax`` to the `BidirectionalCollection` protocol.
 extension UnexpectedNodesSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -9871,8 +9871,8 @@ extension UnexpectedNodesSyntax: BidirectionalCollection {
   }
 }
 
-/// `VersionComponentListSyntax` represents a collection of one or more
-/// `VersionComponentSyntax` nodes. VersionComponentListSyntax behaves
+/// ``VersionComponentListSyntax`` represents a collection of one or more
+/// ``VersionComponentSyntax`` nodes. ``VersionComponentListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct VersionComponentListSyntax: SyntaxCollection, SyntaxHashable {
@@ -9915,12 +9915,12 @@ public struct VersionComponentListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `VersionComponentListSyntax` by replacing the underlying layout with
+  /// Creates a new ``VersionComponentListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `VersionComponentListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``VersionComponentListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> VersionComponentListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -9928,35 +9928,35 @@ public struct VersionComponentListSyntax: SyntaxCollection, SyntaxHashable {
     return VersionComponentListSyntax(newData)
   }
   
-  /// Creates a new `VersionComponentListSyntax` by appending the provided syntax element
+  /// Creates a new ``VersionComponentListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `VersionComponentListSyntax` with that element appended to the end.
+  /// - Returns: A new ``VersionComponentListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> VersionComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `VersionComponentListSyntax` by prepending the provided syntax element
+  /// Creates a new ``VersionComponentListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `VersionComponentListSyntax` with that element prepended to the
+  /// - Returns: A new ``VersionComponentListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> VersionComponentListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `VersionComponentListSyntax` by inserting the provided syntax element
+  /// Creates a new ``VersionComponentListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `VersionComponentListSyntax` with that element appended to the end.
+  /// - Returns: A new ``VersionComponentListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> VersionComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -9966,14 +9966,14 @@ public struct VersionComponentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `VersionComponentListSyntax` by replacing the syntax element
+  /// Creates a new ``VersionComponentListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `VersionComponentListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``VersionComponentListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> VersionComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -9983,11 +9983,11 @@ public struct VersionComponentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `VersionComponentListSyntax` by removing the syntax element at the
+  /// Creates a new ``VersionComponentListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `VersionComponentListSyntax` with the element at the provided index
+  /// - Returns: A new ``VersionComponentListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> VersionComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -9995,18 +9995,18 @@ public struct VersionComponentListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `VersionComponentListSyntax` by removing the first element.
+  /// Creates a new ``VersionComponentListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `VersionComponentListSyntax` with the first element removed.
+  /// - Returns: A new ``VersionComponentListSyntax`` with the first element removed.
   public func removingFirst() -> VersionComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `VersionComponentListSyntax` by removing the last element.
+  /// Creates a new ``VersionComponentListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `VersionComponentListSyntax` with the last element removed.
+  /// - Returns: A new ``VersionComponentListSyntax`` with the last element removed.
   public func removingLast() -> VersionComponentListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -10014,7 +10014,7 @@ public struct VersionComponentListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `VersionComponentListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``VersionComponentListSyntax`` to the `BidirectionalCollection` protocol.
 extension VersionComponentListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
@@ -10080,8 +10080,8 @@ extension VersionComponentListSyntax: BidirectionalCollection {
   }
 }
 
-/// `YieldExprListSyntax` represents a collection of one or more
-/// `YieldExprListElementSyntax` nodes. YieldExprListSyntax behaves
+/// ``YieldExprListSyntax`` represents a collection of one or more
+/// ``YieldExprListElementSyntax`` nodes. ``YieldExprListSyntax`` behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
 public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable {
@@ -10124,12 +10124,12 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable {
     return layoutView.children.count
   }
   
-  /// Creates a new `YieldExprListSyntax` by replacing the underlying layout with
+  /// Creates a new ``YieldExprListSyntax`` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new `YieldExprListSyntax` with the new layout underlying it.
+  /// - Returns: A new ``YieldExprListSyntax`` with the new layout underlying it.
   internal func replacingLayout(_ layout: [RawSyntax?]) -> YieldExprListSyntax {
     let arena = SyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
@@ -10137,35 +10137,35 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable {
     return YieldExprListSyntax(newData)
   }
   
-  /// Creates a new `YieldExprListSyntax` by appending the provided syntax element
+  /// Creates a new ``YieldExprListSyntax`` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new `YieldExprListSyntax` with that element appended to the end.
+  /// - Returns: A new ``YieldExprListSyntax`` with that element appended to the end.
   public func appending(_ syntax: Element) -> YieldExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `YieldExprListSyntax` by prepending the provided syntax element
+  /// Creates a new ``YieldExprListSyntax`` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new `YieldExprListSyntax` with that element prepended to the
+  /// - Returns: A new ``YieldExprListSyntax`` with that element prepended to the
   ///            beginning.
   public func prepending(_ syntax: Element) -> YieldExprListSyntax {
     return inserting(syntax, at: 0)
   }
   
-  /// Creates a new `YieldExprListSyntax` by inserting the provided syntax element
+  /// Creates a new ``YieldExprListSyntax`` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new `YieldExprListSyntax` with that element appended to the end.
+  /// - Returns: A new ``YieldExprListSyntax`` with that element appended to the end.
   public func inserting(_ syntax: Element, at index: Int) -> YieldExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
@@ -10175,14 +10175,14 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `YieldExprListSyntax` by replacing the syntax element
+  /// Creates a new ``YieldExprListSyntax`` by replacing the syntax element
   /// at the provided index.
   ///
   /// - Parameters:
   ///   - index: The index at which to replace the element in the collection.
   ///   - syntax: The element to replace with.
   ///
-  /// - Returns: A new `YieldExprListSyntax` with the new element at the provided index.
+  /// - Returns: A new ``YieldExprListSyntax`` with the new element at the provided index.
   public func replacing(childAt index: Int, with syntax: Element) -> YieldExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
@@ -10192,11 +10192,11 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `YieldExprListSyntax` by removing the syntax element at the
+  /// Creates a new ``YieldExprListSyntax`` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new `YieldExprListSyntax` with the element at the provided index
+  /// - Returns: A new ``YieldExprListSyntax`` with the element at the provided index
   ///            removed.
   public func removing(childAt index: Int) -> YieldExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
@@ -10204,18 +10204,18 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable {
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `YieldExprListSyntax` by removing the first element.
+  /// Creates a new ``YieldExprListSyntax`` by removing the first element.
   ///
-  /// - Returns: A new `YieldExprListSyntax` with the first element removed.
+  /// - Returns: A new ``YieldExprListSyntax`` with the first element removed.
   public func removingFirst() -> YieldExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
   
-  /// Creates a new `YieldExprListSyntax` by removing the last element.
+  /// Creates a new ``YieldExprListSyntax`` by removing the last element.
   ///
-  /// - Returns: A new `YieldExprListSyntax` with the last element removed.
+  /// - Returns: A new ``YieldExprListSyntax`` with the last element removed.
   public func removingLast() -> YieldExprListSyntax {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
@@ -10223,7 +10223,7 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable {
   }
 }
 
-/// Conformance for `YieldExprListSyntax` to the `BidirectionalCollection` protocol.
+/// Conformance for ``YieldExprListSyntax`` to the `BidirectionalCollection` protocol.
 extension YieldExprListSyntax: BidirectionalCollection {
   public typealias Index = SyntaxChildrenIndex
   
diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
index acaeb408747..9aa254e32df 100644
--- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
@@ -25,1925 +25,1925 @@ open class SyntaxRewriter {
   public init() {
   }
   
-  /// Visit a `AccessorBlockSyntax`.
+  /// Visit a ``AccessorBlockSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AccessorBlockSyntax) -> AccessorBlockSyntax {
     return Syntax(visitChildren(node)).cast(AccessorBlockSyntax.self)
   }
   
-  /// Visit a `AccessorDeclSyntax`.
+  /// Visit a ``AccessorDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AccessorDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `AccessorEffectSpecifiersSyntax`.
+  /// Visit a ``AccessorEffectSpecifiersSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AccessorEffectSpecifiersSyntax) -> AccessorEffectSpecifiersSyntax {
     return Syntax(visitChildren(node)).cast(AccessorEffectSpecifiersSyntax.self)
   }
   
-  /// Visit a `AccessorListSyntax`.
+  /// Visit a ``AccessorListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AccessorListSyntax) -> AccessorListSyntax {
     return Syntax(visitChildren(node)).cast(AccessorListSyntax.self)
   }
   
-  /// Visit a `AccessorParameterSyntax`.
+  /// Visit a ``AccessorParameterSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AccessorParameterSyntax) -> AccessorParameterSyntax {
     return Syntax(visitChildren(node)).cast(AccessorParameterSyntax.self)
   }
   
-  /// Visit a `ActorDeclSyntax`.
+  /// Visit a ``ActorDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ActorDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `ArrayElementListSyntax`.
+  /// Visit a ``ArrayElementListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ArrayElementListSyntax) -> ArrayElementListSyntax {
     return Syntax(visitChildren(node)).cast(ArrayElementListSyntax.self)
   }
   
-  /// Visit a `ArrayElementSyntax`.
+  /// Visit a ``ArrayElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ArrayElementSyntax) -> ArrayElementSyntax {
     return Syntax(visitChildren(node)).cast(ArrayElementSyntax.self)
   }
   
-  /// Visit a `ArrayExprSyntax`.
+  /// Visit a ``ArrayExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ArrayExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `ArrayTypeSyntax`.
+  /// Visit a ``ArrayTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ArrayTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `ArrowExprSyntax`.
+  /// Visit a ``ArrowExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ArrowExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `AsExprSyntax`.
+  /// Visit a ``AsExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AsExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `AssignmentExprSyntax`.
+  /// Visit a ``AssignmentExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AssignmentExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `AssociatedtypeDeclSyntax`.
+  /// Visit a ``AssociatedtypeDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AssociatedtypeDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `AttributeListSyntax`.
+  /// Visit a ``AttributeListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AttributeListSyntax) -> AttributeListSyntax {
     return Syntax(visitChildren(node)).cast(AttributeListSyntax.self)
   }
   
-  /// Visit a `AttributeSyntax`.
+  /// Visit a ``AttributeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AttributeSyntax) -> AttributeSyntax {
     return Syntax(visitChildren(node)).cast(AttributeSyntax.self)
   }
   
-  /// Visit a `AttributedTypeSyntax`.
+  /// Visit a ``AttributedTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AttributedTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `AvailabilityArgumentSyntax`.
+  /// Visit a ``AvailabilityArgumentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AvailabilityArgumentSyntax) -> AvailabilityArgumentSyntax {
     return Syntax(visitChildren(node)).cast(AvailabilityArgumentSyntax.self)
   }
   
-  /// Visit a `AvailabilityConditionSyntax`.
+  /// Visit a ``AvailabilityConditionSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AvailabilityConditionSyntax) -> AvailabilityConditionSyntax {
     return Syntax(visitChildren(node)).cast(AvailabilityConditionSyntax.self)
   }
   
-  /// Visit a `AvailabilityEntrySyntax`.
+  /// Visit a ``AvailabilityEntrySyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AvailabilityEntrySyntax) -> AvailabilityEntrySyntax {
     return Syntax(visitChildren(node)).cast(AvailabilityEntrySyntax.self)
   }
   
-  /// Visit a `AvailabilityLabeledArgumentSyntax`.
+  /// Visit a ``AvailabilityLabeledArgumentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AvailabilityLabeledArgumentSyntax) -> AvailabilityLabeledArgumentSyntax {
     return Syntax(visitChildren(node)).cast(AvailabilityLabeledArgumentSyntax.self)
   }
   
-  /// Visit a `AvailabilitySpecListSyntax`.
+  /// Visit a ``AvailabilitySpecListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AvailabilitySpecListSyntax) -> AvailabilitySpecListSyntax {
     return Syntax(visitChildren(node)).cast(AvailabilitySpecListSyntax.self)
   }
   
-  /// Visit a `AvailabilityVersionRestrictionListEntrySyntax`.
+  /// Visit a ``AvailabilityVersionRestrictionListEntrySyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AvailabilityVersionRestrictionListEntrySyntax) -> AvailabilityVersionRestrictionListEntrySyntax {
     return Syntax(visitChildren(node)).cast(AvailabilityVersionRestrictionListEntrySyntax.self)
   }
   
-  /// Visit a `AvailabilityVersionRestrictionListSyntax`.
+  /// Visit a ``AvailabilityVersionRestrictionListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AvailabilityVersionRestrictionListSyntax) -> AvailabilityVersionRestrictionListSyntax {
     return Syntax(visitChildren(node)).cast(AvailabilityVersionRestrictionListSyntax.self)
   }
   
-  /// Visit a `AvailabilityVersionRestrictionSyntax`.
+  /// Visit a ``AvailabilityVersionRestrictionSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AvailabilityVersionRestrictionSyntax) -> AvailabilityVersionRestrictionSyntax {
     return Syntax(visitChildren(node)).cast(AvailabilityVersionRestrictionSyntax.self)
   }
   
-  /// Visit a `AwaitExprSyntax`.
+  /// Visit a ``AwaitExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: AwaitExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `BackDeployedAttributeSpecListSyntax`.
+  /// Visit a ``BackDeployedAttributeSpecListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: BackDeployedAttributeSpecListSyntax) -> BackDeployedAttributeSpecListSyntax {
     return Syntax(visitChildren(node)).cast(BackDeployedAttributeSpecListSyntax.self)
   }
   
-  /// Visit a `BinaryOperatorExprSyntax`.
+  /// Visit a ``BinaryOperatorExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: BinaryOperatorExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `BooleanLiteralExprSyntax`.
+  /// Visit a ``BooleanLiteralExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: BooleanLiteralExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `BorrowExprSyntax`.
+  /// Visit a ``BorrowExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: BorrowExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `BreakStmtSyntax`.
+  /// Visit a ``BreakStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: BreakStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `CanImportExprSyntax`.
+  /// Visit a ``CanImportExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CanImportExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `CanImportVersionInfoSyntax`.
+  /// Visit a ``CanImportVersionInfoSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CanImportVersionInfoSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `CaseItemListSyntax`.
+  /// Visit a ``CaseItemListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CaseItemListSyntax) -> CaseItemListSyntax {
     return Syntax(visitChildren(node)).cast(CaseItemListSyntax.self)
   }
   
-  /// Visit a `CaseItemSyntax`.
+  /// Visit a ``CaseItemSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CaseItemSyntax) -> CaseItemSyntax {
     return Syntax(visitChildren(node)).cast(CaseItemSyntax.self)
   }
   
-  /// Visit a `CatchClauseListSyntax`.
+  /// Visit a ``CatchClauseListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CatchClauseListSyntax) -> CatchClauseListSyntax {
     return Syntax(visitChildren(node)).cast(CatchClauseListSyntax.self)
   }
   
-  /// Visit a `CatchClauseSyntax`.
+  /// Visit a ``CatchClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CatchClauseSyntax) -> CatchClauseSyntax {
     return Syntax(visitChildren(node)).cast(CatchClauseSyntax.self)
   }
   
-  /// Visit a `CatchItemListSyntax`.
+  /// Visit a ``CatchItemListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CatchItemListSyntax) -> CatchItemListSyntax {
     return Syntax(visitChildren(node)).cast(CatchItemListSyntax.self)
   }
   
-  /// Visit a `CatchItemSyntax`.
+  /// Visit a ``CatchItemSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CatchItemSyntax) -> CatchItemSyntax {
     return Syntax(visitChildren(node)).cast(CatchItemSyntax.self)
   }
   
-  /// Visit a `ClassDeclSyntax`.
+  /// Visit a ``ClassDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClassDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `ClassRestrictionTypeSyntax`.
+  /// Visit a ``ClassRestrictionTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClassRestrictionTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `ClosureCaptureItemListSyntax`.
+  /// Visit a ``ClosureCaptureItemListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureCaptureItemListSyntax) -> ClosureCaptureItemListSyntax {
     return Syntax(visitChildren(node)).cast(ClosureCaptureItemListSyntax.self)
   }
   
-  /// Visit a `ClosureCaptureItemSpecifierSyntax`.
+  /// Visit a ``ClosureCaptureItemSpecifierSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureCaptureItemSpecifierSyntax) -> ClosureCaptureItemSpecifierSyntax {
     return Syntax(visitChildren(node)).cast(ClosureCaptureItemSpecifierSyntax.self)
   }
   
-  /// Visit a `ClosureCaptureItemSyntax`.
+  /// Visit a ``ClosureCaptureItemSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureCaptureItemSyntax) -> ClosureCaptureItemSyntax {
     return Syntax(visitChildren(node)).cast(ClosureCaptureItemSyntax.self)
   }
   
-  /// Visit a `ClosureCaptureSignatureSyntax`.
+  /// Visit a ``ClosureCaptureSignatureSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureCaptureSignatureSyntax) -> ClosureCaptureSignatureSyntax {
     return Syntax(visitChildren(node)).cast(ClosureCaptureSignatureSyntax.self)
   }
   
-  /// Visit a `ClosureExprSyntax`.
+  /// Visit a ``ClosureExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `ClosureParamListSyntax`.
+  /// Visit a ``ClosureParamListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureParamListSyntax) -> ClosureParamListSyntax {
     return Syntax(visitChildren(node)).cast(ClosureParamListSyntax.self)
   }
   
-  /// Visit a `ClosureParamSyntax`.
+  /// Visit a ``ClosureParamSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureParamSyntax) -> ClosureParamSyntax {
     return Syntax(visitChildren(node)).cast(ClosureParamSyntax.self)
   }
   
-  /// Visit a `ClosureParameterClauseSyntax`.
+  /// Visit a ``ClosureParameterClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureParameterClauseSyntax) -> ClosureParameterClauseSyntax {
     return Syntax(visitChildren(node)).cast(ClosureParameterClauseSyntax.self)
   }
   
-  /// Visit a `ClosureParameterListSyntax`.
+  /// Visit a ``ClosureParameterListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureParameterListSyntax) -> ClosureParameterListSyntax {
     return Syntax(visitChildren(node)).cast(ClosureParameterListSyntax.self)
   }
   
-  /// Visit a `ClosureParameterSyntax`.
+  /// Visit a ``ClosureParameterSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureParameterSyntax) -> ClosureParameterSyntax {
     return Syntax(visitChildren(node)).cast(ClosureParameterSyntax.self)
   }
   
-  /// Visit a `ClosureSignatureSyntax`.
+  /// Visit a ``ClosureSignatureSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ClosureSignatureSyntax) -> ClosureSignatureSyntax {
     return Syntax(visitChildren(node)).cast(ClosureSignatureSyntax.self)
   }
   
-  /// Visit a `CodeBlockItemListSyntax`.
+  /// Visit a ``CodeBlockItemListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CodeBlockItemListSyntax) -> CodeBlockItemListSyntax {
     return Syntax(visitChildren(node)).cast(CodeBlockItemListSyntax.self)
   }
   
-  /// Visit a `CodeBlockItemSyntax`.
+  /// Visit a ``CodeBlockItemSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CodeBlockItemSyntax) -> CodeBlockItemSyntax {
     return Syntax(visitChildren(node)).cast(CodeBlockItemSyntax.self)
   }
   
-  /// Visit a `CodeBlockSyntax`.
+  /// Visit a ``CodeBlockSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CodeBlockSyntax) -> CodeBlockSyntax {
     return Syntax(visitChildren(node)).cast(CodeBlockSyntax.self)
   }
   
-  /// Visit a `CompositionTypeElementListSyntax`.
+  /// Visit a ``CompositionTypeElementListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CompositionTypeElementListSyntax) -> CompositionTypeElementListSyntax {
     return Syntax(visitChildren(node)).cast(CompositionTypeElementListSyntax.self)
   }
   
-  /// Visit a `CompositionTypeElementSyntax`.
+  /// Visit a ``CompositionTypeElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CompositionTypeElementSyntax) -> CompositionTypeElementSyntax {
     return Syntax(visitChildren(node)).cast(CompositionTypeElementSyntax.self)
   }
   
-  /// Visit a `CompositionTypeSyntax`.
+  /// Visit a ``CompositionTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CompositionTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `ConditionElementListSyntax`.
+  /// Visit a ``ConditionElementListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ConditionElementListSyntax) -> ConditionElementListSyntax {
     return Syntax(visitChildren(node)).cast(ConditionElementListSyntax.self)
   }
   
-  /// Visit a `ConditionElementSyntax`.
+  /// Visit a ``ConditionElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ConditionElementSyntax) -> ConditionElementSyntax {
     return Syntax(visitChildren(node)).cast(ConditionElementSyntax.self)
   }
   
-  /// Visit a `ConformanceRequirementSyntax`.
+  /// Visit a ``ConformanceRequirementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ConformanceRequirementSyntax) -> ConformanceRequirementSyntax {
     return Syntax(visitChildren(node)).cast(ConformanceRequirementSyntax.self)
   }
   
-  /// Visit a `ConstrainedSugarTypeSyntax`.
+  /// Visit a ``ConstrainedSugarTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ConstrainedSugarTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `ContinueStmtSyntax`.
+  /// Visit a ``ContinueStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ContinueStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `ConventionAttributeArgumentsSyntax`.
+  /// Visit a ``ConventionAttributeArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ConventionAttributeArgumentsSyntax) -> ConventionAttributeArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(ConventionAttributeArgumentsSyntax.self)
   }
   
-  /// Visit a `ConventionWitnessMethodAttributeArgumentsSyntax`.
+  /// Visit a ``ConventionWitnessMethodAttributeArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) -> ConventionWitnessMethodAttributeArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(ConventionWitnessMethodAttributeArgumentsSyntax.self)
   }
   
-  /// Visit a `CopyExprSyntax`.
+  /// Visit a ``CopyExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: CopyExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `DeclModifierDetailSyntax`.
+  /// Visit a ``DeclModifierDetailSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DeclModifierDetailSyntax) -> DeclModifierDetailSyntax {
     return Syntax(visitChildren(node)).cast(DeclModifierDetailSyntax.self)
   }
   
-  /// Visit a `DeclModifierSyntax`.
+  /// Visit a ``DeclModifierSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DeclModifierSyntax) -> DeclModifierSyntax {
     return Syntax(visitChildren(node)).cast(DeclModifierSyntax.self)
   }
   
-  /// Visit a `DeclNameArgumentListSyntax`.
+  /// Visit a ``DeclNameArgumentListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DeclNameArgumentListSyntax) -> DeclNameArgumentListSyntax {
     return Syntax(visitChildren(node)).cast(DeclNameArgumentListSyntax.self)
   }
   
-  /// Visit a `DeclNameArgumentSyntax`.
+  /// Visit a ``DeclNameArgumentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DeclNameArgumentSyntax) -> DeclNameArgumentSyntax {
     return Syntax(visitChildren(node)).cast(DeclNameArgumentSyntax.self)
   }
   
-  /// Visit a `DeclNameArgumentsSyntax`.
+  /// Visit a ``DeclNameArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DeclNameArgumentsSyntax) -> DeclNameArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(DeclNameArgumentsSyntax.self)
   }
   
-  /// Visit a `DeclNameSyntax`.
+  /// Visit a ``DeclNameSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DeclNameSyntax) -> DeclNameSyntax {
     return Syntax(visitChildren(node)).cast(DeclNameSyntax.self)
   }
   
-  /// Visit a `DeferStmtSyntax`.
+  /// Visit a ``DeferStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DeferStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `DeinitializerDeclSyntax`.
+  /// Visit a ``DeinitializerDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DeinitializerDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `DerivativeRegistrationAttributeArgumentsSyntax`.
+  /// Visit a ``DerivativeRegistrationAttributeArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DerivativeRegistrationAttributeArgumentsSyntax) -> DerivativeRegistrationAttributeArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(DerivativeRegistrationAttributeArgumentsSyntax.self)
   }
   
-  /// Visit a `DesignatedTypeElementSyntax`.
+  /// Visit a ``DesignatedTypeElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DesignatedTypeElementSyntax) -> DesignatedTypeElementSyntax {
     return Syntax(visitChildren(node)).cast(DesignatedTypeElementSyntax.self)
   }
   
-  /// Visit a `DesignatedTypeListSyntax`.
+  /// Visit a ``DesignatedTypeListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DesignatedTypeListSyntax) -> DesignatedTypeListSyntax {
     return Syntax(visitChildren(node)).cast(DesignatedTypeListSyntax.self)
   }
   
-  /// Visit a `DictionaryElementListSyntax`.
+  /// Visit a ``DictionaryElementListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DictionaryElementListSyntax) -> DictionaryElementListSyntax {
     return Syntax(visitChildren(node)).cast(DictionaryElementListSyntax.self)
   }
   
-  /// Visit a `DictionaryElementSyntax`.
+  /// Visit a ``DictionaryElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DictionaryElementSyntax) -> DictionaryElementSyntax {
     return Syntax(visitChildren(node)).cast(DictionaryElementSyntax.self)
   }
   
-  /// Visit a `DictionaryExprSyntax`.
+  /// Visit a ``DictionaryExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DictionaryExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `DictionaryTypeSyntax`.
+  /// Visit a ``DictionaryTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DictionaryTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `DifferentiabilityParamListSyntax`.
+  /// Visit a ``DifferentiabilityParamListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DifferentiabilityParamListSyntax) -> DifferentiabilityParamListSyntax {
     return Syntax(visitChildren(node)).cast(DifferentiabilityParamListSyntax.self)
   }
   
-  /// Visit a `DifferentiabilityParamSyntax`.
+  /// Visit a ``DifferentiabilityParamSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DifferentiabilityParamSyntax) -> DifferentiabilityParamSyntax {
     return Syntax(visitChildren(node)).cast(DifferentiabilityParamSyntax.self)
   }
   
-  /// Visit a `DifferentiabilityParamsClauseSyntax`.
+  /// Visit a ``DifferentiabilityParamsClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DifferentiabilityParamsClauseSyntax) -> DifferentiabilityParamsClauseSyntax {
     return Syntax(visitChildren(node)).cast(DifferentiabilityParamsClauseSyntax.self)
   }
   
-  /// Visit a `DifferentiabilityParamsSyntax`.
+  /// Visit a ``DifferentiabilityParamsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DifferentiabilityParamsSyntax) -> DifferentiabilityParamsSyntax {
     return Syntax(visitChildren(node)).cast(DifferentiabilityParamsSyntax.self)
   }
   
-  /// Visit a `DifferentiableAttributeArgumentsSyntax`.
+  /// Visit a ``DifferentiableAttributeArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DifferentiableAttributeArgumentsSyntax) -> DifferentiableAttributeArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(DifferentiableAttributeArgumentsSyntax.self)
   }
   
-  /// Visit a `DiscardAssignmentExprSyntax`.
+  /// Visit a ``DiscardAssignmentExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DiscardAssignmentExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `DiscardStmtSyntax`.
+  /// Visit a ``DiscardStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DiscardStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `DoStmtSyntax`.
+  /// Visit a ``DoStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DoStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `DocumentationAttributeArgumentSyntax`.
+  /// Visit a ``DocumentationAttributeArgumentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DocumentationAttributeArgumentSyntax) -> DocumentationAttributeArgumentSyntax {
     return Syntax(visitChildren(node)).cast(DocumentationAttributeArgumentSyntax.self)
   }
   
-  /// Visit a `DocumentationAttributeArgumentsSyntax`.
+  /// Visit a ``DocumentationAttributeArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DocumentationAttributeArgumentsSyntax) -> DocumentationAttributeArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(DocumentationAttributeArgumentsSyntax.self)
   }
   
-  /// Visit a `DynamicReplacementArgumentsSyntax`.
+  /// Visit a ``DynamicReplacementArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: DynamicReplacementArgumentsSyntax) -> DynamicReplacementArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(DynamicReplacementArgumentsSyntax.self)
   }
   
-  /// Visit a `EditorPlaceholderDeclSyntax`.
+  /// Visit a ``EditorPlaceholderDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: EditorPlaceholderDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `EditorPlaceholderExprSyntax`.
+  /// Visit a ``EditorPlaceholderExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: EditorPlaceholderExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `EffectsArgumentsSyntax`.
+  /// Visit a ``EffectsArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: EffectsArgumentsSyntax) -> EffectsArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(EffectsArgumentsSyntax.self)
   }
   
-  /// Visit a `EnumCaseDeclSyntax`.
+  /// Visit a ``EnumCaseDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: EnumCaseDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `EnumCaseElementListSyntax`.
+  /// Visit a ``EnumCaseElementListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: EnumCaseElementListSyntax) -> EnumCaseElementListSyntax {
     return Syntax(visitChildren(node)).cast(EnumCaseElementListSyntax.self)
   }
   
-  /// Visit a `EnumCaseElementSyntax`.
+  /// Visit a ``EnumCaseElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: EnumCaseElementSyntax) -> EnumCaseElementSyntax {
     return Syntax(visitChildren(node)).cast(EnumCaseElementSyntax.self)
   }
   
-  /// Visit a `EnumCaseParameterClauseSyntax`.
+  /// Visit a ``EnumCaseParameterClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: EnumCaseParameterClauseSyntax) -> EnumCaseParameterClauseSyntax {
     return Syntax(visitChildren(node)).cast(EnumCaseParameterClauseSyntax.self)
   }
   
-  /// Visit a `EnumCaseParameterListSyntax`.
+  /// Visit a ``EnumCaseParameterListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: EnumCaseParameterListSyntax) -> EnumCaseParameterListSyntax {
     return Syntax(visitChildren(node)).cast(EnumCaseParameterListSyntax.self)
   }
   
-  /// Visit a `EnumCaseParameterSyntax`.
+  /// Visit a ``EnumCaseParameterSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: EnumCaseParameterSyntax) -> EnumCaseParameterSyntax {
     return Syntax(visitChildren(node)).cast(EnumCaseParameterSyntax.self)
   }
   
-  /// Visit a `EnumDeclSyntax`.
+  /// Visit a ``EnumDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: EnumDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `ExposeAttributeArgumentsSyntax`.
+  /// Visit a ``ExposeAttributeArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ExposeAttributeArgumentsSyntax) -> ExposeAttributeArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(ExposeAttributeArgumentsSyntax.self)
   }
   
-  /// Visit a `ExprListSyntax`.
+  /// Visit a ``ExprListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ExprListSyntax) -> ExprListSyntax {
     return Syntax(visitChildren(node)).cast(ExprListSyntax.self)
   }
   
-  /// Visit a `ExpressionPatternSyntax`.
+  /// Visit a ``ExpressionPatternSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ExpressionPatternSyntax) -> PatternSyntax {
     return PatternSyntax(visitChildren(node))
   }
   
-  /// Visit a `ExpressionSegmentSyntax`.
+  /// Visit a ``ExpressionSegmentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ExpressionSegmentSyntax) -> ExpressionSegmentSyntax {
     return Syntax(visitChildren(node)).cast(ExpressionSegmentSyntax.self)
   }
   
-  /// Visit a `ExpressionStmtSyntax`.
+  /// Visit a ``ExpressionStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ExpressionStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `ExtensionDeclSyntax`.
+  /// Visit a ``ExtensionDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ExtensionDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `FallthroughStmtSyntax`.
+  /// Visit a ``FallthroughStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: FallthroughStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `FloatLiteralExprSyntax`.
+  /// Visit a ``FloatLiteralExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: FloatLiteralExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `ForInStmtSyntax`.
+  /// Visit a ``ForInStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ForInStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `ForcedValueExprSyntax`.
+  /// Visit a ``ForcedValueExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ForcedValueExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `FunctionCallExprSyntax`.
+  /// Visit a ``FunctionCallExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: FunctionCallExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `FunctionDeclSyntax`.
+  /// Visit a ``FunctionDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: FunctionDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `FunctionEffectSpecifiersSyntax`.
+  /// Visit a ``FunctionEffectSpecifiersSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: FunctionEffectSpecifiersSyntax) -> FunctionEffectSpecifiersSyntax {
     return Syntax(visitChildren(node)).cast(FunctionEffectSpecifiersSyntax.self)
   }
   
-  /// Visit a `FunctionParameterListSyntax`.
+  /// Visit a ``FunctionParameterListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: FunctionParameterListSyntax) -> FunctionParameterListSyntax {
     return Syntax(visitChildren(node)).cast(FunctionParameterListSyntax.self)
   }
   
-  /// Visit a `FunctionParameterSyntax`.
+  /// Visit a ``FunctionParameterSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: FunctionParameterSyntax) -> FunctionParameterSyntax {
     return Syntax(visitChildren(node)).cast(FunctionParameterSyntax.self)
   }
   
-  /// Visit a `FunctionSignatureSyntax`.
+  /// Visit a ``FunctionSignatureSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: FunctionSignatureSyntax) -> FunctionSignatureSyntax {
     return Syntax(visitChildren(node)).cast(FunctionSignatureSyntax.self)
   }
   
-  /// Visit a `FunctionTypeSyntax`.
+  /// Visit a ``FunctionTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: FunctionTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `GenericArgumentClauseSyntax`.
+  /// Visit a ``GenericArgumentClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: GenericArgumentClauseSyntax) -> GenericArgumentClauseSyntax {
     return Syntax(visitChildren(node)).cast(GenericArgumentClauseSyntax.self)
   }
   
-  /// Visit a `GenericArgumentListSyntax`.
+  /// Visit a ``GenericArgumentListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: GenericArgumentListSyntax) -> GenericArgumentListSyntax {
     return Syntax(visitChildren(node)).cast(GenericArgumentListSyntax.self)
   }
   
-  /// Visit a `GenericArgumentSyntax`.
+  /// Visit a ``GenericArgumentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: GenericArgumentSyntax) -> GenericArgumentSyntax {
     return Syntax(visitChildren(node)).cast(GenericArgumentSyntax.self)
   }
   
-  /// Visit a `GenericParameterClauseSyntax`.
+  /// Visit a ``GenericParameterClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: GenericParameterClauseSyntax) -> GenericParameterClauseSyntax {
     return Syntax(visitChildren(node)).cast(GenericParameterClauseSyntax.self)
   }
   
-  /// Visit a `GenericParameterListSyntax`.
+  /// Visit a ``GenericParameterListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: GenericParameterListSyntax) -> GenericParameterListSyntax {
     return Syntax(visitChildren(node)).cast(GenericParameterListSyntax.self)
   }
   
-  /// Visit a `GenericParameterSyntax`.
+  /// Visit a ``GenericParameterSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: GenericParameterSyntax) -> GenericParameterSyntax {
     return Syntax(visitChildren(node)).cast(GenericParameterSyntax.self)
   }
   
-  /// Visit a `GenericRequirementListSyntax`.
+  /// Visit a ``GenericRequirementListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: GenericRequirementListSyntax) -> GenericRequirementListSyntax {
     return Syntax(visitChildren(node)).cast(GenericRequirementListSyntax.self)
   }
   
-  /// Visit a `GenericRequirementSyntax`.
+  /// Visit a ``GenericRequirementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: GenericRequirementSyntax) -> GenericRequirementSyntax {
     return Syntax(visitChildren(node)).cast(GenericRequirementSyntax.self)
   }
   
-  /// Visit a `GenericWhereClauseSyntax`.
+  /// Visit a ``GenericWhereClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: GenericWhereClauseSyntax) -> GenericWhereClauseSyntax {
     return Syntax(visitChildren(node)).cast(GenericWhereClauseSyntax.self)
   }
   
-  /// Visit a `GuardStmtSyntax`.
+  /// Visit a ``GuardStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: GuardStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `IdentifierExprSyntax`.
+  /// Visit a ``IdentifierExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: IdentifierExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `IdentifierPatternSyntax`.
+  /// Visit a ``IdentifierPatternSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: IdentifierPatternSyntax) -> PatternSyntax {
     return PatternSyntax(visitChildren(node))
   }
   
-  /// Visit a `IfConfigClauseListSyntax`.
+  /// Visit a ``IfConfigClauseListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: IfConfigClauseListSyntax) -> IfConfigClauseListSyntax {
     return Syntax(visitChildren(node)).cast(IfConfigClauseListSyntax.self)
   }
   
-  /// Visit a `IfConfigClauseSyntax`.
+  /// Visit a ``IfConfigClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: IfConfigClauseSyntax) -> IfConfigClauseSyntax {
     return Syntax(visitChildren(node)).cast(IfConfigClauseSyntax.self)
   }
   
-  /// Visit a `IfConfigDeclSyntax`.
+  /// Visit a ``IfConfigDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: IfConfigDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `IfExprSyntax`.
+  /// Visit a ``IfExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: IfExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `ImplementsAttributeArgumentsSyntax`.
+  /// Visit a ``ImplementsAttributeArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ImplementsAttributeArgumentsSyntax) -> ImplementsAttributeArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(ImplementsAttributeArgumentsSyntax.self)
   }
   
-  /// Visit a `ImplicitlyUnwrappedOptionalTypeSyntax`.
+  /// Visit a ``ImplicitlyUnwrappedOptionalTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ImplicitlyUnwrappedOptionalTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `ImportDeclSyntax`.
+  /// Visit a ``ImportDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ImportDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `ImportPathComponentSyntax`.
+  /// Visit a ``ImportPathComponentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ImportPathComponentSyntax) -> ImportPathComponentSyntax {
     return Syntax(visitChildren(node)).cast(ImportPathComponentSyntax.self)
   }
   
-  /// Visit a `ImportPathSyntax`.
+  /// Visit a ``ImportPathSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ImportPathSyntax) -> ImportPathSyntax {
     return Syntax(visitChildren(node)).cast(ImportPathSyntax.self)
   }
   
-  /// Visit a `InOutExprSyntax`.
+  /// Visit a ``InOutExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: InOutExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `InfixOperatorExprSyntax`.
+  /// Visit a ``InfixOperatorExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: InfixOperatorExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `InheritedTypeListSyntax`.
+  /// Visit a ``InheritedTypeListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: InheritedTypeListSyntax) -> InheritedTypeListSyntax {
     return Syntax(visitChildren(node)).cast(InheritedTypeListSyntax.self)
   }
   
-  /// Visit a `InheritedTypeSyntax`.
+  /// Visit a ``InheritedTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: InheritedTypeSyntax) -> InheritedTypeSyntax {
     return Syntax(visitChildren(node)).cast(InheritedTypeSyntax.self)
   }
   
-  /// Visit a `InitializerClauseSyntax`.
+  /// Visit a ``InitializerClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: InitializerClauseSyntax) -> InitializerClauseSyntax {
     return Syntax(visitChildren(node)).cast(InitializerClauseSyntax.self)
   }
   
-  /// Visit a `InitializerDeclSyntax`.
+  /// Visit a ``InitializerDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: InitializerDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `IntegerLiteralExprSyntax`.
+  /// Visit a ``IntegerLiteralExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: IntegerLiteralExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `IsExprSyntax`.
+  /// Visit a ``IsExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: IsExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `IsTypePatternSyntax`.
+  /// Visit a ``IsTypePatternSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: IsTypePatternSyntax) -> PatternSyntax {
     return PatternSyntax(visitChildren(node))
   }
   
-  /// Visit a `KeyPathComponentListSyntax`.
+  /// Visit a ``KeyPathComponentListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: KeyPathComponentListSyntax) -> KeyPathComponentListSyntax {
     return Syntax(visitChildren(node)).cast(KeyPathComponentListSyntax.self)
   }
   
-  /// Visit a `KeyPathComponentSyntax`.
+  /// Visit a ``KeyPathComponentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: KeyPathComponentSyntax) -> KeyPathComponentSyntax {
     return Syntax(visitChildren(node)).cast(KeyPathComponentSyntax.self)
   }
   
-  /// Visit a `KeyPathExprSyntax`.
+  /// Visit a ``KeyPathExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: KeyPathExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `KeyPathOptionalComponentSyntax`.
+  /// Visit a ``KeyPathOptionalComponentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: KeyPathOptionalComponentSyntax) -> KeyPathOptionalComponentSyntax {
     return Syntax(visitChildren(node)).cast(KeyPathOptionalComponentSyntax.self)
   }
   
-  /// Visit a `KeyPathPropertyComponentSyntax`.
+  /// Visit a ``KeyPathPropertyComponentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: KeyPathPropertyComponentSyntax) -> KeyPathPropertyComponentSyntax {
     return Syntax(visitChildren(node)).cast(KeyPathPropertyComponentSyntax.self)
   }
   
-  /// Visit a `KeyPathSubscriptComponentSyntax`.
+  /// Visit a ``KeyPathSubscriptComponentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: KeyPathSubscriptComponentSyntax) -> KeyPathSubscriptComponentSyntax {
     return Syntax(visitChildren(node)).cast(KeyPathSubscriptComponentSyntax.self)
   }
   
-  /// Visit a `LabeledSpecializeEntrySyntax`.
+  /// Visit a ``LabeledSpecializeEntrySyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: LabeledSpecializeEntrySyntax) -> LabeledSpecializeEntrySyntax {
     return Syntax(visitChildren(node)).cast(LabeledSpecializeEntrySyntax.self)
   }
   
-  /// Visit a `LabeledStmtSyntax`.
+  /// Visit a ``LabeledStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: LabeledStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `LayoutRequirementSyntax`.
+  /// Visit a ``LayoutRequirementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: LayoutRequirementSyntax) -> LayoutRequirementSyntax {
     return Syntax(visitChildren(node)).cast(LayoutRequirementSyntax.self)
   }
   
-  /// Visit a `MacroDeclSyntax`.
+  /// Visit a ``MacroDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MacroDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `MacroExpansionDeclSyntax`.
+  /// Visit a ``MacroExpansionDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MacroExpansionDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `MacroExpansionExprSyntax`.
+  /// Visit a ``MacroExpansionExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MacroExpansionExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `MatchingPatternConditionSyntax`.
+  /// Visit a ``MatchingPatternConditionSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MatchingPatternConditionSyntax) -> MatchingPatternConditionSyntax {
     return Syntax(visitChildren(node)).cast(MatchingPatternConditionSyntax.self)
   }
   
-  /// Visit a `MemberAccessExprSyntax`.
+  /// Visit a ``MemberAccessExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MemberAccessExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `MemberDeclBlockSyntax`.
+  /// Visit a ``MemberDeclBlockSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MemberDeclBlockSyntax) -> MemberDeclBlockSyntax {
     return Syntax(visitChildren(node)).cast(MemberDeclBlockSyntax.self)
   }
   
-  /// Visit a `MemberDeclListItemSyntax`.
+  /// Visit a ``MemberDeclListItemSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MemberDeclListItemSyntax) -> MemberDeclListItemSyntax {
     return Syntax(visitChildren(node)).cast(MemberDeclListItemSyntax.self)
   }
   
-  /// Visit a `MemberDeclListSyntax`.
+  /// Visit a ``MemberDeclListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MemberDeclListSyntax) -> MemberDeclListSyntax {
     return Syntax(visitChildren(node)).cast(MemberDeclListSyntax.self)
   }
   
-  /// Visit a `MemberTypeIdentifierSyntax`.
+  /// Visit a ``MemberTypeIdentifierSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MemberTypeIdentifierSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `MetatypeTypeSyntax`.
+  /// Visit a ``MetatypeTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MetatypeTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `MissingDeclSyntax`.
+  /// Visit a ``MissingDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MissingDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `MissingExprSyntax`.
+  /// Visit a ``MissingExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MissingExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `MissingPatternSyntax`.
+  /// Visit a ``MissingPatternSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MissingPatternSyntax) -> PatternSyntax {
     return PatternSyntax(visitChildren(node))
   }
   
-  /// Visit a `MissingStmtSyntax`.
+  /// Visit a ``MissingStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MissingStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `MissingSyntax`.
+  /// Visit a ``MissingSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MissingSyntax) -> Syntax {
     return Syntax(visitChildren(node))
   }
   
-  /// Visit a `MissingTypeSyntax`.
+  /// Visit a ``MissingTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MissingTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `ModifierListSyntax`.
+  /// Visit a ``ModifierListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ModifierListSyntax) -> ModifierListSyntax {
     return Syntax(visitChildren(node)).cast(ModifierListSyntax.self)
   }
   
-  /// Visit a `MoveExprSyntax`.
+  /// Visit a ``MoveExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MoveExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `MultipleTrailingClosureElementListSyntax`.
+  /// Visit a ``MultipleTrailingClosureElementListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MultipleTrailingClosureElementListSyntax) -> MultipleTrailingClosureElementListSyntax {
     return Syntax(visitChildren(node)).cast(MultipleTrailingClosureElementListSyntax.self)
   }
   
-  /// Visit a `MultipleTrailingClosureElementSyntax`.
+  /// Visit a ``MultipleTrailingClosureElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: MultipleTrailingClosureElementSyntax) -> MultipleTrailingClosureElementSyntax {
     return Syntax(visitChildren(node)).cast(MultipleTrailingClosureElementSyntax.self)
   }
   
-  /// Visit a `NamedOpaqueReturnTypeSyntax`.
+  /// Visit a ``NamedOpaqueReturnTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: NamedOpaqueReturnTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `NilLiteralExprSyntax`.
+  /// Visit a ``NilLiteralExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: NilLiteralExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `ObjCSelectorPieceSyntax`.
+  /// Visit a ``ObjCSelectorPieceSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ObjCSelectorPieceSyntax) -> ObjCSelectorPieceSyntax {
     return Syntax(visitChildren(node)).cast(ObjCSelectorPieceSyntax.self)
   }
   
-  /// Visit a `ObjCSelectorSyntax`.
+  /// Visit a ``ObjCSelectorSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ObjCSelectorSyntax) -> ObjCSelectorSyntax {
     return Syntax(visitChildren(node)).cast(ObjCSelectorSyntax.self)
   }
   
-  /// Visit a `OpaqueReturnTypeOfAttributeArgumentsSyntax`.
+  /// Visit a ``OpaqueReturnTypeOfAttributeArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) -> OpaqueReturnTypeOfAttributeArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(OpaqueReturnTypeOfAttributeArgumentsSyntax.self)
   }
   
-  /// Visit a `OperatorDeclSyntax`.
+  /// Visit a ``OperatorDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: OperatorDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `OperatorPrecedenceAndTypesSyntax`.
+  /// Visit a ``OperatorPrecedenceAndTypesSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: OperatorPrecedenceAndTypesSyntax) -> OperatorPrecedenceAndTypesSyntax {
     return Syntax(visitChildren(node)).cast(OperatorPrecedenceAndTypesSyntax.self)
   }
   
-  /// Visit a `OptionalBindingConditionSyntax`.
+  /// Visit a ``OptionalBindingConditionSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: OptionalBindingConditionSyntax) -> OptionalBindingConditionSyntax {
     return Syntax(visitChildren(node)).cast(OptionalBindingConditionSyntax.self)
   }
   
-  /// Visit a `OptionalChainingExprSyntax`.
+  /// Visit a ``OptionalChainingExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: OptionalChainingExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `OptionalTypeSyntax`.
+  /// Visit a ``OptionalTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: OptionalTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `OriginallyDefinedInArgumentsSyntax`.
+  /// Visit a ``OriginallyDefinedInArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: OriginallyDefinedInArgumentsSyntax) -> OriginallyDefinedInArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(OriginallyDefinedInArgumentsSyntax.self)
   }
   
-  /// Visit a `PackElementExprSyntax`.
+  /// Visit a ``PackElementExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PackElementExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `PackExpansionExprSyntax`.
+  /// Visit a ``PackExpansionExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PackExpansionExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `PackExpansionTypeSyntax`.
+  /// Visit a ``PackExpansionTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PackExpansionTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `PackReferenceTypeSyntax`.
+  /// Visit a ``PackReferenceTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PackReferenceTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `ParameterClauseSyntax`.
+  /// Visit a ``ParameterClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ParameterClauseSyntax) -> ParameterClauseSyntax {
     return Syntax(visitChildren(node)).cast(ParameterClauseSyntax.self)
   }
   
-  /// Visit a `PatternBindingListSyntax`.
+  /// Visit a ``PatternBindingListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PatternBindingListSyntax) -> PatternBindingListSyntax {
     return Syntax(visitChildren(node)).cast(PatternBindingListSyntax.self)
   }
   
-  /// Visit a `PatternBindingSyntax`.
+  /// Visit a ``PatternBindingSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PatternBindingSyntax) -> PatternBindingSyntax {
     return Syntax(visitChildren(node)).cast(PatternBindingSyntax.self)
   }
   
-  /// Visit a `PostfixIfConfigExprSyntax`.
+  /// Visit a ``PostfixIfConfigExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PostfixIfConfigExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `PostfixUnaryExprSyntax`.
+  /// Visit a ``PostfixUnaryExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PostfixUnaryExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `PoundSourceLocationArgsSyntax`.
+  /// Visit a ``PoundSourceLocationArgsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PoundSourceLocationArgsSyntax) -> PoundSourceLocationArgsSyntax {
     return Syntax(visitChildren(node)).cast(PoundSourceLocationArgsSyntax.self)
   }
   
-  /// Visit a `PoundSourceLocationSyntax`.
+  /// Visit a ``PoundSourceLocationSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PoundSourceLocationSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `PrecedenceGroupAssignmentSyntax`.
+  /// Visit a ``PrecedenceGroupAssignmentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrecedenceGroupAssignmentSyntax) -> PrecedenceGroupAssignmentSyntax {
     return Syntax(visitChildren(node)).cast(PrecedenceGroupAssignmentSyntax.self)
   }
   
-  /// Visit a `PrecedenceGroupAssociativitySyntax`.
+  /// Visit a ``PrecedenceGroupAssociativitySyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrecedenceGroupAssociativitySyntax) -> PrecedenceGroupAssociativitySyntax {
     return Syntax(visitChildren(node)).cast(PrecedenceGroupAssociativitySyntax.self)
   }
   
-  /// Visit a `PrecedenceGroupAttributeListSyntax`.
+  /// Visit a ``PrecedenceGroupAttributeListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrecedenceGroupAttributeListSyntax) -> PrecedenceGroupAttributeListSyntax {
     return Syntax(visitChildren(node)).cast(PrecedenceGroupAttributeListSyntax.self)
   }
   
-  /// Visit a `PrecedenceGroupDeclSyntax`.
+  /// Visit a ``PrecedenceGroupDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrecedenceGroupDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `PrecedenceGroupNameElementSyntax`.
+  /// Visit a ``PrecedenceGroupNameElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrecedenceGroupNameElementSyntax) -> PrecedenceGroupNameElementSyntax {
     return Syntax(visitChildren(node)).cast(PrecedenceGroupNameElementSyntax.self)
   }
   
-  /// Visit a `PrecedenceGroupNameListSyntax`.
+  /// Visit a ``PrecedenceGroupNameListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrecedenceGroupNameListSyntax) -> PrecedenceGroupNameListSyntax {
     return Syntax(visitChildren(node)).cast(PrecedenceGroupNameListSyntax.self)
   }
   
-  /// Visit a `PrecedenceGroupRelationSyntax`.
+  /// Visit a ``PrecedenceGroupRelationSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrecedenceGroupRelationSyntax) -> PrecedenceGroupRelationSyntax {
     return Syntax(visitChildren(node)).cast(PrecedenceGroupRelationSyntax.self)
   }
   
-  /// Visit a `PrefixOperatorExprSyntax`.
+  /// Visit a ``PrefixOperatorExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrefixOperatorExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `PrimaryAssociatedTypeClauseSyntax`.
+  /// Visit a ``PrimaryAssociatedTypeClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrimaryAssociatedTypeClauseSyntax) -> PrimaryAssociatedTypeClauseSyntax {
     return Syntax(visitChildren(node)).cast(PrimaryAssociatedTypeClauseSyntax.self)
   }
   
-  /// Visit a `PrimaryAssociatedTypeListSyntax`.
+  /// Visit a ``PrimaryAssociatedTypeListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrimaryAssociatedTypeListSyntax) -> PrimaryAssociatedTypeListSyntax {
     return Syntax(visitChildren(node)).cast(PrimaryAssociatedTypeListSyntax.self)
   }
   
-  /// Visit a `PrimaryAssociatedTypeSyntax`.
+  /// Visit a ``PrimaryAssociatedTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: PrimaryAssociatedTypeSyntax) -> PrimaryAssociatedTypeSyntax {
     return Syntax(visitChildren(node)).cast(PrimaryAssociatedTypeSyntax.self)
   }
   
-  /// Visit a `ProtocolDeclSyntax`.
+  /// Visit a ``ProtocolDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ProtocolDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `QualifiedDeclNameSyntax`.
+  /// Visit a ``QualifiedDeclNameSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: QualifiedDeclNameSyntax) -> QualifiedDeclNameSyntax {
     return Syntax(visitChildren(node)).cast(QualifiedDeclNameSyntax.self)
   }
   
-  /// Visit a `RegexLiteralExprSyntax`.
+  /// Visit a ``RegexLiteralExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: RegexLiteralExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `RepeatWhileStmtSyntax`.
+  /// Visit a ``RepeatWhileStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: RepeatWhileStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `ReturnClauseSyntax`.
+  /// Visit a ``ReturnClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ReturnClauseSyntax) -> ReturnClauseSyntax {
     return Syntax(visitChildren(node)).cast(ReturnClauseSyntax.self)
   }
   
-  /// Visit a `ReturnStmtSyntax`.
+  /// Visit a ``ReturnStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ReturnStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `SameTypeRequirementSyntax`.
+  /// Visit a ``SameTypeRequirementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SameTypeRequirementSyntax) -> SameTypeRequirementSyntax {
     return Syntax(visitChildren(node)).cast(SameTypeRequirementSyntax.self)
   }
   
-  /// Visit a `SequenceExprSyntax`.
+  /// Visit a ``SequenceExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SequenceExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `SimpleTypeIdentifierSyntax`.
+  /// Visit a ``SimpleTypeIdentifierSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SimpleTypeIdentifierSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `SourceFileSyntax`.
+  /// Visit a ``SourceFileSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SourceFileSyntax) -> SourceFileSyntax {
     return Syntax(visitChildren(node)).cast(SourceFileSyntax.self)
   }
   
-  /// Visit a `SpecializeAttributeSpecListSyntax`.
+  /// Visit a ``SpecializeAttributeSpecListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SpecializeAttributeSpecListSyntax) -> SpecializeAttributeSpecListSyntax {
     return Syntax(visitChildren(node)).cast(SpecializeAttributeSpecListSyntax.self)
   }
   
-  /// Visit a `SpecializeExprSyntax`.
+  /// Visit a ``SpecializeExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SpecializeExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `StringLiteralExprSyntax`.
+  /// Visit a ``StringLiteralExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: StringLiteralExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `StringLiteralSegmentsSyntax`.
+  /// Visit a ``StringLiteralSegmentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: StringLiteralSegmentsSyntax) -> StringLiteralSegmentsSyntax {
     return Syntax(visitChildren(node)).cast(StringLiteralSegmentsSyntax.self)
   }
   
-  /// Visit a `StringSegmentSyntax`.
+  /// Visit a ``StringSegmentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: StringSegmentSyntax) -> StringSegmentSyntax {
     return Syntax(visitChildren(node)).cast(StringSegmentSyntax.self)
   }
   
-  /// Visit a `StructDeclSyntax`.
+  /// Visit a ``StructDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: StructDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `SubscriptDeclSyntax`.
+  /// Visit a ``SubscriptDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SubscriptDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `SubscriptExprSyntax`.
+  /// Visit a ``SubscriptExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SubscriptExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `SuperRefExprSyntax`.
+  /// Visit a ``SuperRefExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SuperRefExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `SuppressedTypeSyntax`.
+  /// Visit a ``SuppressedTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SuppressedTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `SwitchCaseLabelSyntax`.
+  /// Visit a ``SwitchCaseLabelSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SwitchCaseLabelSyntax) -> SwitchCaseLabelSyntax {
     return Syntax(visitChildren(node)).cast(SwitchCaseLabelSyntax.self)
   }
   
-  /// Visit a `SwitchCaseListSyntax`.
+  /// Visit a ``SwitchCaseListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SwitchCaseListSyntax) -> SwitchCaseListSyntax {
     return Syntax(visitChildren(node)).cast(SwitchCaseListSyntax.self)
   }
   
-  /// Visit a `SwitchCaseSyntax`.
+  /// Visit a ``SwitchCaseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SwitchCaseSyntax) -> SwitchCaseSyntax {
     return Syntax(visitChildren(node)).cast(SwitchCaseSyntax.self)
   }
   
-  /// Visit a `SwitchDefaultLabelSyntax`.
+  /// Visit a ``SwitchDefaultLabelSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SwitchDefaultLabelSyntax) -> SwitchDefaultLabelSyntax {
     return Syntax(visitChildren(node)).cast(SwitchDefaultLabelSyntax.self)
   }
   
-  /// Visit a `SwitchExprSyntax`.
+  /// Visit a ``SwitchExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: SwitchExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `TargetFunctionEntrySyntax`.
+  /// Visit a ``TargetFunctionEntrySyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TargetFunctionEntrySyntax) -> TargetFunctionEntrySyntax {
     return Syntax(visitChildren(node)).cast(TargetFunctionEntrySyntax.self)
   }
   
-  /// Visit a `TernaryExprSyntax`.
+  /// Visit a ``TernaryExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TernaryExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `ThrowStmtSyntax`.
+  /// Visit a ``ThrowStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ThrowStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `TryExprSyntax`.
+  /// Visit a ``TryExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TryExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `TupleExprElementListSyntax`.
+  /// Visit a ``TupleExprElementListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TupleExprElementListSyntax) -> TupleExprElementListSyntax {
     return Syntax(visitChildren(node)).cast(TupleExprElementListSyntax.self)
   }
   
-  /// Visit a `TupleExprElementSyntax`.
+  /// Visit a ``TupleExprElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TupleExprElementSyntax) -> TupleExprElementSyntax {
     return Syntax(visitChildren(node)).cast(TupleExprElementSyntax.self)
   }
   
-  /// Visit a `TupleExprSyntax`.
+  /// Visit a ``TupleExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TupleExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `TuplePatternElementListSyntax`.
+  /// Visit a ``TuplePatternElementListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TuplePatternElementListSyntax) -> TuplePatternElementListSyntax {
     return Syntax(visitChildren(node)).cast(TuplePatternElementListSyntax.self)
   }
   
-  /// Visit a `TuplePatternElementSyntax`.
+  /// Visit a ``TuplePatternElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TuplePatternElementSyntax) -> TuplePatternElementSyntax {
     return Syntax(visitChildren(node)).cast(TuplePatternElementSyntax.self)
   }
   
-  /// Visit a `TuplePatternSyntax`.
+  /// Visit a ``TuplePatternSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TuplePatternSyntax) -> PatternSyntax {
     return PatternSyntax(visitChildren(node))
   }
   
-  /// Visit a `TupleTypeElementListSyntax`.
+  /// Visit a ``TupleTypeElementListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TupleTypeElementListSyntax) -> TupleTypeElementListSyntax {
     return Syntax(visitChildren(node)).cast(TupleTypeElementListSyntax.self)
   }
   
-  /// Visit a `TupleTypeElementSyntax`.
+  /// Visit a ``TupleTypeElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TupleTypeElementSyntax) -> TupleTypeElementSyntax {
     return Syntax(visitChildren(node)).cast(TupleTypeElementSyntax.self)
   }
   
-  /// Visit a `TupleTypeSyntax`.
+  /// Visit a ``TupleTypeSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TupleTypeSyntax) -> TypeSyntax {
     return TypeSyntax(visitChildren(node))
   }
   
-  /// Visit a `TypeAnnotationSyntax`.
+  /// Visit a ``TypeAnnotationSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TypeAnnotationSyntax) -> TypeAnnotationSyntax {
     return Syntax(visitChildren(node)).cast(TypeAnnotationSyntax.self)
   }
   
-  /// Visit a `TypeEffectSpecifiersSyntax`.
+  /// Visit a ``TypeEffectSpecifiersSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TypeEffectSpecifiersSyntax) -> TypeEffectSpecifiersSyntax {
     return Syntax(visitChildren(node)).cast(TypeEffectSpecifiersSyntax.self)
   }
   
-  /// Visit a `TypeExprSyntax`.
+  /// Visit a ``TypeExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TypeExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `TypeInheritanceClauseSyntax`.
+  /// Visit a ``TypeInheritanceClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TypeInheritanceClauseSyntax) -> TypeInheritanceClauseSyntax {
     return Syntax(visitChildren(node)).cast(TypeInheritanceClauseSyntax.self)
   }
   
-  /// Visit a `TypeInitializerClauseSyntax`.
+  /// Visit a ``TypeInitializerClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TypeInitializerClauseSyntax) -> TypeInitializerClauseSyntax {
     return Syntax(visitChildren(node)).cast(TypeInitializerClauseSyntax.self)
   }
   
-  /// Visit a `TypealiasDeclSyntax`.
+  /// Visit a ``TypealiasDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: TypealiasDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `UnavailableFromAsyncArgumentsSyntax`.
+  /// Visit a ``UnavailableFromAsyncArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: UnavailableFromAsyncArgumentsSyntax) -> UnavailableFromAsyncArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(UnavailableFromAsyncArgumentsSyntax.self)
   }
   
-  /// Visit a `UnderscorePrivateAttributeArgumentsSyntax`.
+  /// Visit a ``UnderscorePrivateAttributeArgumentsSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: UnderscorePrivateAttributeArgumentsSyntax) -> UnderscorePrivateAttributeArgumentsSyntax {
     return Syntax(visitChildren(node)).cast(UnderscorePrivateAttributeArgumentsSyntax.self)
   }
   
-  /// Visit a `UnexpectedNodesSyntax`.
+  /// Visit a ``UnexpectedNodesSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: UnexpectedNodesSyntax) -> UnexpectedNodesSyntax {
     return Syntax(visitChildren(node)).cast(UnexpectedNodesSyntax.self)
   }
   
-  /// Visit a `UnresolvedAsExprSyntax`.
+  /// Visit a ``UnresolvedAsExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: UnresolvedAsExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `UnresolvedIsExprSyntax`.
+  /// Visit a ``UnresolvedIsExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: UnresolvedIsExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `UnresolvedPatternExprSyntax`.
+  /// Visit a ``UnresolvedPatternExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: UnresolvedPatternExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `UnresolvedTernaryExprSyntax`.
+  /// Visit a ``UnresolvedTernaryExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: UnresolvedTernaryExprSyntax) -> ExprSyntax {
     return ExprSyntax(visitChildren(node))
   }
   
-  /// Visit a `ValueBindingPatternSyntax`.
+  /// Visit a ``ValueBindingPatternSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: ValueBindingPatternSyntax) -> PatternSyntax {
     return PatternSyntax(visitChildren(node))
   }
   
-  /// Visit a `VariableDeclSyntax`.
+  /// Visit a ``VariableDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: VariableDeclSyntax) -> DeclSyntax {
     return DeclSyntax(visitChildren(node))
   }
   
-  /// Visit a `VersionComponentListSyntax`.
+  /// Visit a ``VersionComponentListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: VersionComponentListSyntax) -> VersionComponentListSyntax {
     return Syntax(visitChildren(node)).cast(VersionComponentListSyntax.self)
   }
   
-  /// Visit a `VersionComponentSyntax`.
+  /// Visit a ``VersionComponentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: VersionComponentSyntax) -> VersionComponentSyntax {
     return Syntax(visitChildren(node)).cast(VersionComponentSyntax.self)
   }
   
-  /// Visit a `VersionTupleSyntax`.
+  /// Visit a ``VersionTupleSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: VersionTupleSyntax) -> VersionTupleSyntax {
     return Syntax(visitChildren(node)).cast(VersionTupleSyntax.self)
   }
   
-  /// Visit a `WhereClauseSyntax`.
+  /// Visit a ``WhereClauseSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: WhereClauseSyntax) -> WhereClauseSyntax {
     return Syntax(visitChildren(node)).cast(WhereClauseSyntax.self)
   }
   
-  /// Visit a `WhileStmtSyntax`.
+  /// Visit a ``WhileStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: WhileStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `WildcardPatternSyntax`.
+  /// Visit a ``WildcardPatternSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: WildcardPatternSyntax) -> PatternSyntax {
     return PatternSyntax(visitChildren(node))
   }
   
-  /// Visit a `YieldExprListElementSyntax`.
+  /// Visit a ``YieldExprListElementSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: YieldExprListElementSyntax) -> YieldExprListElementSyntax {
     return Syntax(visitChildren(node)).cast(YieldExprListElementSyntax.self)
   }
   
-  /// Visit a `YieldExprListSyntax`.
+  /// Visit a ``YieldExprListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: YieldExprListSyntax) -> YieldExprListSyntax {
     return Syntax(visitChildren(node)).cast(YieldExprListSyntax.self)
   }
   
-  /// Visit a `YieldListSyntax`.
+  /// Visit a ``YieldListSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: YieldListSyntax) -> YieldListSyntax {
     return Syntax(visitChildren(node)).cast(YieldListSyntax.self)
   }
   
-  /// Visit a `YieldStmtSyntax`.
+  /// Visit a ``YieldStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ node: YieldStmtSyntax) -> StmtSyntax {
     return StmtSyntax(visitChildren(node))
   }
   
-  /// Visit a `TokenSyntax`.
+  /// Visit a ``TokenSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
   open func visit(_ token: TokenSyntax) -> TokenSyntax {
diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift
index a54ca1c679c..b829db1334e 100644
--- a/Sources/SwiftSyntax/generated/SyntaxTransform.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxTransform.swift
@@ -19,1372 +19,1372 @@ public protocol SyntaxTransformVisitor {
   
   func visit(_ token: TokenSyntax) -> ResultType
   
-  /// Visiting `AccessorBlockSyntax` specifically.
+  /// Visiting ``AccessorBlockSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AccessorBlockSyntax) -> ResultType
   
-  /// Visiting `AccessorDeclSyntax` specifically.
+  /// Visiting ``AccessorDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AccessorDeclSyntax) -> ResultType
   
-  /// Visiting `AccessorEffectSpecifiersSyntax` specifically.
+  /// Visiting ``AccessorEffectSpecifiersSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AccessorEffectSpecifiersSyntax) -> ResultType
   
-  /// Visiting `AccessorListSyntax` specifically.
+  /// Visiting ``AccessorListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AccessorListSyntax) -> ResultType
   
-  /// Visiting `AccessorParameterSyntax` specifically.
+  /// Visiting ``AccessorParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AccessorParameterSyntax) -> ResultType
   
-  /// Visiting `ActorDeclSyntax` specifically.
+  /// Visiting ``ActorDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ActorDeclSyntax) -> ResultType
   
-  /// Visiting `ArrayElementListSyntax` specifically.
+  /// Visiting ``ArrayElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ArrayElementListSyntax) -> ResultType
   
-  /// Visiting `ArrayElementSyntax` specifically.
+  /// Visiting ``ArrayElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ArrayElementSyntax) -> ResultType
   
-  /// Visiting `ArrayExprSyntax` specifically.
+  /// Visiting ``ArrayExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ArrayExprSyntax) -> ResultType
   
-  /// Visiting `ArrayTypeSyntax` specifically.
+  /// Visiting ``ArrayTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ArrayTypeSyntax) -> ResultType
   
-  /// Visiting `ArrowExprSyntax` specifically.
+  /// Visiting ``ArrowExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ArrowExprSyntax) -> ResultType
   
-  /// Visiting `AsExprSyntax` specifically.
+  /// Visiting ``AsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AsExprSyntax) -> ResultType
   
-  /// Visiting `AssignmentExprSyntax` specifically.
+  /// Visiting ``AssignmentExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AssignmentExprSyntax) -> ResultType
   
-  /// Visiting `AssociatedtypeDeclSyntax` specifically.
+  /// Visiting ``AssociatedtypeDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AssociatedtypeDeclSyntax) -> ResultType
   
-  /// Visiting `AttributeListSyntax` specifically.
+  /// Visiting ``AttributeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AttributeListSyntax) -> ResultType
   
-  /// Visiting `AttributeSyntax` specifically.
+  /// Visiting ``AttributeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AttributeSyntax) -> ResultType
   
-  /// Visiting `AttributedTypeSyntax` specifically.
+  /// Visiting ``AttributedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AttributedTypeSyntax) -> ResultType
   
-  /// Visiting `AvailabilityArgumentSyntax` specifically.
+  /// Visiting ``AvailabilityArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AvailabilityArgumentSyntax) -> ResultType
   
-  /// Visiting `AvailabilityConditionSyntax` specifically.
+  /// Visiting ``AvailabilityConditionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AvailabilityConditionSyntax) -> ResultType
   
-  /// Visiting `AvailabilityEntrySyntax` specifically.
+  /// Visiting ``AvailabilityEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AvailabilityEntrySyntax) -> ResultType
   
-  /// Visiting `AvailabilityLabeledArgumentSyntax` specifically.
+  /// Visiting ``AvailabilityLabeledArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AvailabilityLabeledArgumentSyntax) -> ResultType
   
-  /// Visiting `AvailabilitySpecListSyntax` specifically.
+  /// Visiting ``AvailabilitySpecListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AvailabilitySpecListSyntax) -> ResultType
   
-  /// Visiting `AvailabilityVersionRestrictionListEntrySyntax` specifically.
+  /// Visiting ``AvailabilityVersionRestrictionListEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AvailabilityVersionRestrictionListEntrySyntax) -> ResultType
   
-  /// Visiting `AvailabilityVersionRestrictionListSyntax` specifically.
+  /// Visiting ``AvailabilityVersionRestrictionListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AvailabilityVersionRestrictionListSyntax) -> ResultType
   
-  /// Visiting `AvailabilityVersionRestrictionSyntax` specifically.
+  /// Visiting ``AvailabilityVersionRestrictionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AvailabilityVersionRestrictionSyntax) -> ResultType
   
-  /// Visiting `AwaitExprSyntax` specifically.
+  /// Visiting ``AwaitExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AwaitExprSyntax) -> ResultType
   
-  /// Visiting `BackDeployedAttributeSpecListSyntax` specifically.
+  /// Visiting ``BackDeployedAttributeSpecListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: BackDeployedAttributeSpecListSyntax) -> ResultType
   
-  /// Visiting `BinaryOperatorExprSyntax` specifically.
+  /// Visiting ``BinaryOperatorExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: BinaryOperatorExprSyntax) -> ResultType
   
-  /// Visiting `BooleanLiteralExprSyntax` specifically.
+  /// Visiting ``BooleanLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: BooleanLiteralExprSyntax) -> ResultType
   
-  /// Visiting `BorrowExprSyntax` specifically.
+  /// Visiting ``BorrowExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: BorrowExprSyntax) -> ResultType
   
-  /// Visiting `BreakStmtSyntax` specifically.
+  /// Visiting ``BreakStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: BreakStmtSyntax) -> ResultType
   
-  /// Visiting `CanImportExprSyntax` specifically.
+  /// Visiting ``CanImportExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CanImportExprSyntax) -> ResultType
   
-  /// Visiting `CanImportVersionInfoSyntax` specifically.
+  /// Visiting ``CanImportVersionInfoSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CanImportVersionInfoSyntax) -> ResultType
   
-  /// Visiting `CaseItemListSyntax` specifically.
+  /// Visiting ``CaseItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CaseItemListSyntax) -> ResultType
   
-  /// Visiting `CaseItemSyntax` specifically.
+  /// Visiting ``CaseItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CaseItemSyntax) -> ResultType
   
-  /// Visiting `CatchClauseListSyntax` specifically.
+  /// Visiting ``CatchClauseListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CatchClauseListSyntax) -> ResultType
   
-  /// Visiting `CatchClauseSyntax` specifically.
+  /// Visiting ``CatchClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CatchClauseSyntax) -> ResultType
   
-  /// Visiting `CatchItemListSyntax` specifically.
+  /// Visiting ``CatchItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CatchItemListSyntax) -> ResultType
   
-  /// Visiting `CatchItemSyntax` specifically.
+  /// Visiting ``CatchItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CatchItemSyntax) -> ResultType
   
-  /// Visiting `ClassDeclSyntax` specifically.
+  /// Visiting ``ClassDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClassDeclSyntax) -> ResultType
   
-  /// Visiting `ClassRestrictionTypeSyntax` specifically.
+  /// Visiting ``ClassRestrictionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClassRestrictionTypeSyntax) -> ResultType
   
-  /// Visiting `ClosureCaptureItemListSyntax` specifically.
+  /// Visiting ``ClosureCaptureItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureCaptureItemListSyntax) -> ResultType
   
-  /// Visiting `ClosureCaptureItemSpecifierSyntax` specifically.
+  /// Visiting ``ClosureCaptureItemSpecifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureCaptureItemSpecifierSyntax) -> ResultType
   
-  /// Visiting `ClosureCaptureItemSyntax` specifically.
+  /// Visiting ``ClosureCaptureItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureCaptureItemSyntax) -> ResultType
   
-  /// Visiting `ClosureCaptureSignatureSyntax` specifically.
+  /// Visiting ``ClosureCaptureSignatureSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureCaptureSignatureSyntax) -> ResultType
   
-  /// Visiting `ClosureExprSyntax` specifically.
+  /// Visiting ``ClosureExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureExprSyntax) -> ResultType
   
-  /// Visiting `ClosureParamListSyntax` specifically.
+  /// Visiting ``ClosureParamListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureParamListSyntax) -> ResultType
   
-  /// Visiting `ClosureParamSyntax` specifically.
+  /// Visiting ``ClosureParamSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureParamSyntax) -> ResultType
   
-  /// Visiting `ClosureParameterClauseSyntax` specifically.
+  /// Visiting ``ClosureParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureParameterClauseSyntax) -> ResultType
   
-  /// Visiting `ClosureParameterListSyntax` specifically.
+  /// Visiting ``ClosureParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureParameterListSyntax) -> ResultType
   
-  /// Visiting `ClosureParameterSyntax` specifically.
+  /// Visiting ``ClosureParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureParameterSyntax) -> ResultType
   
-  /// Visiting `ClosureSignatureSyntax` specifically.
+  /// Visiting ``ClosureSignatureSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ClosureSignatureSyntax) -> ResultType
   
-  /// Visiting `CodeBlockItemListSyntax` specifically.
+  /// Visiting ``CodeBlockItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CodeBlockItemListSyntax) -> ResultType
   
-  /// Visiting `CodeBlockItemSyntax` specifically.
+  /// Visiting ``CodeBlockItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CodeBlockItemSyntax) -> ResultType
   
-  /// Visiting `CodeBlockSyntax` specifically.
+  /// Visiting ``CodeBlockSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CodeBlockSyntax) -> ResultType
   
-  /// Visiting `CompositionTypeElementListSyntax` specifically.
+  /// Visiting ``CompositionTypeElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CompositionTypeElementListSyntax) -> ResultType
   
-  /// Visiting `CompositionTypeElementSyntax` specifically.
+  /// Visiting ``CompositionTypeElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CompositionTypeElementSyntax) -> ResultType
   
-  /// Visiting `CompositionTypeSyntax` specifically.
+  /// Visiting ``CompositionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CompositionTypeSyntax) -> ResultType
   
-  /// Visiting `ConditionElementListSyntax` specifically.
+  /// Visiting ``ConditionElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ConditionElementListSyntax) -> ResultType
   
-  /// Visiting `ConditionElementSyntax` specifically.
+  /// Visiting ``ConditionElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ConditionElementSyntax) -> ResultType
   
-  /// Visiting `ConformanceRequirementSyntax` specifically.
+  /// Visiting ``ConformanceRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ConformanceRequirementSyntax) -> ResultType
   
-  /// Visiting `ConstrainedSugarTypeSyntax` specifically.
+  /// Visiting ``ConstrainedSugarTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ConstrainedSugarTypeSyntax) -> ResultType
   
-  /// Visiting `ContinueStmtSyntax` specifically.
+  /// Visiting ``ContinueStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ContinueStmtSyntax) -> ResultType
   
-  /// Visiting `ConventionAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ConventionAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ConventionAttributeArgumentsSyntax) -> ResultType
   
-  /// Visiting `ConventionWitnessMethodAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ConventionWitnessMethodAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) -> ResultType
   
-  /// Visiting `CopyExprSyntax` specifically.
+  /// Visiting ``CopyExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: CopyExprSyntax) -> ResultType
   
-  /// Visiting `DeclModifierDetailSyntax` specifically.
+  /// Visiting ``DeclModifierDetailSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DeclModifierDetailSyntax) -> ResultType
   
-  /// Visiting `DeclModifierSyntax` specifically.
+  /// Visiting ``DeclModifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DeclModifierSyntax) -> ResultType
   
-  /// Visiting `DeclNameArgumentListSyntax` specifically.
+  /// Visiting ``DeclNameArgumentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DeclNameArgumentListSyntax) -> ResultType
   
-  /// Visiting `DeclNameArgumentSyntax` specifically.
+  /// Visiting ``DeclNameArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DeclNameArgumentSyntax) -> ResultType
   
-  /// Visiting `DeclNameArgumentsSyntax` specifically.
+  /// Visiting ``DeclNameArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DeclNameArgumentsSyntax) -> ResultType
   
-  /// Visiting `DeclNameSyntax` specifically.
+  /// Visiting ``DeclNameSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DeclNameSyntax) -> ResultType
   
-  /// Visiting `DeferStmtSyntax` specifically.
+  /// Visiting ``DeferStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DeferStmtSyntax) -> ResultType
   
-  /// Visiting `DeinitializerDeclSyntax` specifically.
+  /// Visiting ``DeinitializerDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DeinitializerDeclSyntax) -> ResultType
   
-  /// Visiting `DerivativeRegistrationAttributeArgumentsSyntax` specifically.
+  /// Visiting ``DerivativeRegistrationAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DerivativeRegistrationAttributeArgumentsSyntax) -> ResultType
   
-  /// Visiting `DesignatedTypeElementSyntax` specifically.
+  /// Visiting ``DesignatedTypeElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DesignatedTypeElementSyntax) -> ResultType
   
-  /// Visiting `DesignatedTypeListSyntax` specifically.
+  /// Visiting ``DesignatedTypeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DesignatedTypeListSyntax) -> ResultType
   
-  /// Visiting `DictionaryElementListSyntax` specifically.
+  /// Visiting ``DictionaryElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DictionaryElementListSyntax) -> ResultType
   
-  /// Visiting `DictionaryElementSyntax` specifically.
+  /// Visiting ``DictionaryElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DictionaryElementSyntax) -> ResultType
   
-  /// Visiting `DictionaryExprSyntax` specifically.
+  /// Visiting ``DictionaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DictionaryExprSyntax) -> ResultType
   
-  /// Visiting `DictionaryTypeSyntax` specifically.
+  /// Visiting ``DictionaryTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DictionaryTypeSyntax) -> ResultType
   
-  /// Visiting `DifferentiabilityParamListSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DifferentiabilityParamListSyntax) -> ResultType
   
-  /// Visiting `DifferentiabilityParamSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DifferentiabilityParamSyntax) -> ResultType
   
-  /// Visiting `DifferentiabilityParamsClauseSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamsClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DifferentiabilityParamsClauseSyntax) -> ResultType
   
-  /// Visiting `DifferentiabilityParamsSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DifferentiabilityParamsSyntax) -> ResultType
   
-  /// Visiting `DifferentiableAttributeArgumentsSyntax` specifically.
+  /// Visiting ``DifferentiableAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DifferentiableAttributeArgumentsSyntax) -> ResultType
   
-  /// Visiting `DiscardAssignmentExprSyntax` specifically.
+  /// Visiting ``DiscardAssignmentExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DiscardAssignmentExprSyntax) -> ResultType
   
-  /// Visiting `DiscardStmtSyntax` specifically.
+  /// Visiting ``DiscardStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DiscardStmtSyntax) -> ResultType
   
-  /// Visiting `DoStmtSyntax` specifically.
+  /// Visiting ``DoStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DoStmtSyntax) -> ResultType
   
-  /// Visiting `DocumentationAttributeArgumentSyntax` specifically.
+  /// Visiting ``DocumentationAttributeArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DocumentationAttributeArgumentSyntax) -> ResultType
   
-  /// Visiting `DocumentationAttributeArgumentsSyntax` specifically.
+  /// Visiting ``DocumentationAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DocumentationAttributeArgumentsSyntax) -> ResultType
   
-  /// Visiting `DynamicReplacementArgumentsSyntax` specifically.
+  /// Visiting ``DynamicReplacementArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: DynamicReplacementArgumentsSyntax) -> ResultType
   
-  /// Visiting `EditorPlaceholderDeclSyntax` specifically.
+  /// Visiting ``EditorPlaceholderDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: EditorPlaceholderDeclSyntax) -> ResultType
   
-  /// Visiting `EditorPlaceholderExprSyntax` specifically.
+  /// Visiting ``EditorPlaceholderExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: EditorPlaceholderExprSyntax) -> ResultType
   
-  /// Visiting `EffectsArgumentsSyntax` specifically.
+  /// Visiting ``EffectsArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: EffectsArgumentsSyntax) -> ResultType
   
-  /// Visiting `EnumCaseDeclSyntax` specifically.
+  /// Visiting ``EnumCaseDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: EnumCaseDeclSyntax) -> ResultType
   
-  /// Visiting `EnumCaseElementListSyntax` specifically.
+  /// Visiting ``EnumCaseElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: EnumCaseElementListSyntax) -> ResultType
   
-  /// Visiting `EnumCaseElementSyntax` specifically.
+  /// Visiting ``EnumCaseElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: EnumCaseElementSyntax) -> ResultType
   
-  /// Visiting `EnumCaseParameterClauseSyntax` specifically.
+  /// Visiting ``EnumCaseParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: EnumCaseParameterClauseSyntax) -> ResultType
   
-  /// Visiting `EnumCaseParameterListSyntax` specifically.
+  /// Visiting ``EnumCaseParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: EnumCaseParameterListSyntax) -> ResultType
   
-  /// Visiting `EnumCaseParameterSyntax` specifically.
+  /// Visiting ``EnumCaseParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: EnumCaseParameterSyntax) -> ResultType
   
-  /// Visiting `EnumDeclSyntax` specifically.
+  /// Visiting ``EnumDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: EnumDeclSyntax) -> ResultType
   
-  /// Visiting `ExposeAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ExposeAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ExposeAttributeArgumentsSyntax) -> ResultType
   
-  /// Visiting `ExprListSyntax` specifically.
+  /// Visiting ``ExprListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ExprListSyntax) -> ResultType
   
-  /// Visiting `ExpressionPatternSyntax` specifically.
+  /// Visiting ``ExpressionPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ExpressionPatternSyntax) -> ResultType
   
-  /// Visiting `ExpressionSegmentSyntax` specifically.
+  /// Visiting ``ExpressionSegmentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ExpressionSegmentSyntax) -> ResultType
   
-  /// Visiting `ExpressionStmtSyntax` specifically.
+  /// Visiting ``ExpressionStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ExpressionStmtSyntax) -> ResultType
   
-  /// Visiting `ExtensionDeclSyntax` specifically.
+  /// Visiting ``ExtensionDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ExtensionDeclSyntax) -> ResultType
   
-  /// Visiting `FallthroughStmtSyntax` specifically.
+  /// Visiting ``FallthroughStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: FallthroughStmtSyntax) -> ResultType
   
-  /// Visiting `FloatLiteralExprSyntax` specifically.
+  /// Visiting ``FloatLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: FloatLiteralExprSyntax) -> ResultType
   
-  /// Visiting `ForInStmtSyntax` specifically.
+  /// Visiting ``ForInStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ForInStmtSyntax) -> ResultType
   
-  /// Visiting `ForcedValueExprSyntax` specifically.
+  /// Visiting ``ForcedValueExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ForcedValueExprSyntax) -> ResultType
   
-  /// Visiting `FunctionCallExprSyntax` specifically.
+  /// Visiting ``FunctionCallExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: FunctionCallExprSyntax) -> ResultType
   
-  /// Visiting `FunctionDeclSyntax` specifically.
+  /// Visiting ``FunctionDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: FunctionDeclSyntax) -> ResultType
   
-  /// Visiting `FunctionEffectSpecifiersSyntax` specifically.
+  /// Visiting ``FunctionEffectSpecifiersSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: FunctionEffectSpecifiersSyntax) -> ResultType
   
-  /// Visiting `FunctionParameterListSyntax` specifically.
+  /// Visiting ``FunctionParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: FunctionParameterListSyntax) -> ResultType
   
-  /// Visiting `FunctionParameterSyntax` specifically.
+  /// Visiting ``FunctionParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: FunctionParameterSyntax) -> ResultType
   
-  /// Visiting `FunctionSignatureSyntax` specifically.
+  /// Visiting ``FunctionSignatureSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: FunctionSignatureSyntax) -> ResultType
   
-  /// Visiting `FunctionTypeSyntax` specifically.
+  /// Visiting ``FunctionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: FunctionTypeSyntax) -> ResultType
   
-  /// Visiting `GenericArgumentClauseSyntax` specifically.
+  /// Visiting ``GenericArgumentClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GenericArgumentClauseSyntax) -> ResultType
   
-  /// Visiting `GenericArgumentListSyntax` specifically.
+  /// Visiting ``GenericArgumentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GenericArgumentListSyntax) -> ResultType
   
-  /// Visiting `GenericArgumentSyntax` specifically.
+  /// Visiting ``GenericArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GenericArgumentSyntax) -> ResultType
   
-  /// Visiting `GenericParameterClauseSyntax` specifically.
+  /// Visiting ``GenericParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GenericParameterClauseSyntax) -> ResultType
   
-  /// Visiting `GenericParameterListSyntax` specifically.
+  /// Visiting ``GenericParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GenericParameterListSyntax) -> ResultType
   
-  /// Visiting `GenericParameterSyntax` specifically.
+  /// Visiting ``GenericParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GenericParameterSyntax) -> ResultType
   
-  /// Visiting `GenericRequirementListSyntax` specifically.
+  /// Visiting ``GenericRequirementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GenericRequirementListSyntax) -> ResultType
   
-  /// Visiting `GenericRequirementSyntax` specifically.
+  /// Visiting ``GenericRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GenericRequirementSyntax) -> ResultType
   
-  /// Visiting `GenericWhereClauseSyntax` specifically.
+  /// Visiting ``GenericWhereClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GenericWhereClauseSyntax) -> ResultType
   
-  /// Visiting `GuardStmtSyntax` specifically.
+  /// Visiting ``GuardStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GuardStmtSyntax) -> ResultType
   
-  /// Visiting `IdentifierExprSyntax` specifically.
+  /// Visiting ``IdentifierExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: IdentifierExprSyntax) -> ResultType
   
-  /// Visiting `IdentifierPatternSyntax` specifically.
+  /// Visiting ``IdentifierPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: IdentifierPatternSyntax) -> ResultType
   
-  /// Visiting `IfConfigClauseListSyntax` specifically.
+  /// Visiting ``IfConfigClauseListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: IfConfigClauseListSyntax) -> ResultType
   
-  /// Visiting `IfConfigClauseSyntax` specifically.
+  /// Visiting ``IfConfigClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: IfConfigClauseSyntax) -> ResultType
   
-  /// Visiting `IfConfigDeclSyntax` specifically.
+  /// Visiting ``IfConfigDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: IfConfigDeclSyntax) -> ResultType
   
-  /// Visiting `IfExprSyntax` specifically.
+  /// Visiting ``IfExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: IfExprSyntax) -> ResultType
   
-  /// Visiting `ImplementsAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ImplementsAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ImplementsAttributeArgumentsSyntax) -> ResultType
   
-  /// Visiting `ImplicitlyUnwrappedOptionalTypeSyntax` specifically.
+  /// Visiting ``ImplicitlyUnwrappedOptionalTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ImplicitlyUnwrappedOptionalTypeSyntax) -> ResultType
   
-  /// Visiting `ImportDeclSyntax` specifically.
+  /// Visiting ``ImportDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ImportDeclSyntax) -> ResultType
   
-  /// Visiting `ImportPathComponentSyntax` specifically.
+  /// Visiting ``ImportPathComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ImportPathComponentSyntax) -> ResultType
   
-  /// Visiting `ImportPathSyntax` specifically.
+  /// Visiting ``ImportPathSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ImportPathSyntax) -> ResultType
   
-  /// Visiting `InOutExprSyntax` specifically.
+  /// Visiting ``InOutExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: InOutExprSyntax) -> ResultType
   
-  /// Visiting `InfixOperatorExprSyntax` specifically.
+  /// Visiting ``InfixOperatorExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: InfixOperatorExprSyntax) -> ResultType
   
-  /// Visiting `InheritedTypeListSyntax` specifically.
+  /// Visiting ``InheritedTypeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: InheritedTypeListSyntax) -> ResultType
   
-  /// Visiting `InheritedTypeSyntax` specifically.
+  /// Visiting ``InheritedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: InheritedTypeSyntax) -> ResultType
   
-  /// Visiting `InitializerClauseSyntax` specifically.
+  /// Visiting ``InitializerClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: InitializerClauseSyntax) -> ResultType
   
-  /// Visiting `InitializerDeclSyntax` specifically.
+  /// Visiting ``InitializerDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: InitializerDeclSyntax) -> ResultType
   
-  /// Visiting `IntegerLiteralExprSyntax` specifically.
+  /// Visiting ``IntegerLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: IntegerLiteralExprSyntax) -> ResultType
   
-  /// Visiting `IsExprSyntax` specifically.
+  /// Visiting ``IsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: IsExprSyntax) -> ResultType
   
-  /// Visiting `IsTypePatternSyntax` specifically.
+  /// Visiting ``IsTypePatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: IsTypePatternSyntax) -> ResultType
   
-  /// Visiting `KeyPathComponentListSyntax` specifically.
+  /// Visiting ``KeyPathComponentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: KeyPathComponentListSyntax) -> ResultType
   
-  /// Visiting `KeyPathComponentSyntax` specifically.
+  /// Visiting ``KeyPathComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: KeyPathComponentSyntax) -> ResultType
   
-  /// Visiting `KeyPathExprSyntax` specifically.
+  /// Visiting ``KeyPathExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: KeyPathExprSyntax) -> ResultType
   
-  /// Visiting `KeyPathOptionalComponentSyntax` specifically.
+  /// Visiting ``KeyPathOptionalComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: KeyPathOptionalComponentSyntax) -> ResultType
   
-  /// Visiting `KeyPathPropertyComponentSyntax` specifically.
+  /// Visiting ``KeyPathPropertyComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: KeyPathPropertyComponentSyntax) -> ResultType
   
-  /// Visiting `KeyPathSubscriptComponentSyntax` specifically.
+  /// Visiting ``KeyPathSubscriptComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: KeyPathSubscriptComponentSyntax) -> ResultType
   
-  /// Visiting `LabeledSpecializeEntrySyntax` specifically.
+  /// Visiting ``LabeledSpecializeEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: LabeledSpecializeEntrySyntax) -> ResultType
   
-  /// Visiting `LabeledStmtSyntax` specifically.
+  /// Visiting ``LabeledStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: LabeledStmtSyntax) -> ResultType
   
-  /// Visiting `LayoutRequirementSyntax` specifically.
+  /// Visiting ``LayoutRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: LayoutRequirementSyntax) -> ResultType
   
-  /// Visiting `MacroDeclSyntax` specifically.
+  /// Visiting ``MacroDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MacroDeclSyntax) -> ResultType
   
-  /// Visiting `MacroExpansionDeclSyntax` specifically.
+  /// Visiting ``MacroExpansionDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MacroExpansionDeclSyntax) -> ResultType
   
-  /// Visiting `MacroExpansionExprSyntax` specifically.
+  /// Visiting ``MacroExpansionExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MacroExpansionExprSyntax) -> ResultType
   
-  /// Visiting `MatchingPatternConditionSyntax` specifically.
+  /// Visiting ``MatchingPatternConditionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MatchingPatternConditionSyntax) -> ResultType
   
-  /// Visiting `MemberAccessExprSyntax` specifically.
+  /// Visiting ``MemberAccessExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MemberAccessExprSyntax) -> ResultType
   
-  /// Visiting `MemberDeclBlockSyntax` specifically.
+  /// Visiting ``MemberDeclBlockSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MemberDeclBlockSyntax) -> ResultType
   
-  /// Visiting `MemberDeclListItemSyntax` specifically.
+  /// Visiting ``MemberDeclListItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MemberDeclListItemSyntax) -> ResultType
   
-  /// Visiting `MemberDeclListSyntax` specifically.
+  /// Visiting ``MemberDeclListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MemberDeclListSyntax) -> ResultType
   
-  /// Visiting `MemberTypeIdentifierSyntax` specifically.
+  /// Visiting ``MemberTypeIdentifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MemberTypeIdentifierSyntax) -> ResultType
   
-  /// Visiting `MetatypeTypeSyntax` specifically.
+  /// Visiting ``MetatypeTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MetatypeTypeSyntax) -> ResultType
   
-  /// Visiting `MissingDeclSyntax` specifically.
+  /// Visiting ``MissingDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MissingDeclSyntax) -> ResultType
   
-  /// Visiting `MissingExprSyntax` specifically.
+  /// Visiting ``MissingExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MissingExprSyntax) -> ResultType
   
-  /// Visiting `MissingPatternSyntax` specifically.
+  /// Visiting ``MissingPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MissingPatternSyntax) -> ResultType
   
-  /// Visiting `MissingStmtSyntax` specifically.
+  /// Visiting ``MissingStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MissingStmtSyntax) -> ResultType
   
-  /// Visiting `MissingSyntax` specifically.
+  /// Visiting ``MissingSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MissingSyntax) -> ResultType
   
-  /// Visiting `MissingTypeSyntax` specifically.
+  /// Visiting ``MissingTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MissingTypeSyntax) -> ResultType
   
-  /// Visiting `ModifierListSyntax` specifically.
+  /// Visiting ``ModifierListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ModifierListSyntax) -> ResultType
   
-  /// Visiting `MoveExprSyntax` specifically.
+  /// Visiting ``MoveExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MoveExprSyntax) -> ResultType
   
-  /// Visiting `MultipleTrailingClosureElementListSyntax` specifically.
+  /// Visiting ``MultipleTrailingClosureElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MultipleTrailingClosureElementListSyntax) -> ResultType
   
-  /// Visiting `MultipleTrailingClosureElementSyntax` specifically.
+  /// Visiting ``MultipleTrailingClosureElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MultipleTrailingClosureElementSyntax) -> ResultType
   
-  /// Visiting `NamedOpaqueReturnTypeSyntax` specifically.
+  /// Visiting ``NamedOpaqueReturnTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: NamedOpaqueReturnTypeSyntax) -> ResultType
   
-  /// Visiting `NilLiteralExprSyntax` specifically.
+  /// Visiting ``NilLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: NilLiteralExprSyntax) -> ResultType
   
-  /// Visiting `ObjCSelectorPieceSyntax` specifically.
+  /// Visiting ``ObjCSelectorPieceSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ObjCSelectorPieceSyntax) -> ResultType
   
-  /// Visiting `ObjCSelectorSyntax` specifically.
+  /// Visiting ``ObjCSelectorSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ObjCSelectorSyntax) -> ResultType
   
-  /// Visiting `OpaqueReturnTypeOfAttributeArgumentsSyntax` specifically.
+  /// Visiting ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) -> ResultType
   
-  /// Visiting `OperatorDeclSyntax` specifically.
+  /// Visiting ``OperatorDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: OperatorDeclSyntax) -> ResultType
   
-  /// Visiting `OperatorPrecedenceAndTypesSyntax` specifically.
+  /// Visiting ``OperatorPrecedenceAndTypesSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: OperatorPrecedenceAndTypesSyntax) -> ResultType
   
-  /// Visiting `OptionalBindingConditionSyntax` specifically.
+  /// Visiting ``OptionalBindingConditionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: OptionalBindingConditionSyntax) -> ResultType
   
-  /// Visiting `OptionalChainingExprSyntax` specifically.
+  /// Visiting ``OptionalChainingExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: OptionalChainingExprSyntax) -> ResultType
   
-  /// Visiting `OptionalTypeSyntax` specifically.
+  /// Visiting ``OptionalTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: OptionalTypeSyntax) -> ResultType
   
-  /// Visiting `OriginallyDefinedInArgumentsSyntax` specifically.
+  /// Visiting ``OriginallyDefinedInArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: OriginallyDefinedInArgumentsSyntax) -> ResultType
   
-  /// Visiting `PackElementExprSyntax` specifically.
+  /// Visiting ``PackElementExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PackElementExprSyntax) -> ResultType
   
-  /// Visiting `PackExpansionExprSyntax` specifically.
+  /// Visiting ``PackExpansionExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PackExpansionExprSyntax) -> ResultType
   
-  /// Visiting `PackExpansionTypeSyntax` specifically.
+  /// Visiting ``PackExpansionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PackExpansionTypeSyntax) -> ResultType
   
-  /// Visiting `PackReferenceTypeSyntax` specifically.
+  /// Visiting ``PackReferenceTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PackReferenceTypeSyntax) -> ResultType
   
-  /// Visiting `ParameterClauseSyntax` specifically.
+  /// Visiting ``ParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ParameterClauseSyntax) -> ResultType
   
-  /// Visiting `PatternBindingListSyntax` specifically.
+  /// Visiting ``PatternBindingListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PatternBindingListSyntax) -> ResultType
   
-  /// Visiting `PatternBindingSyntax` specifically.
+  /// Visiting ``PatternBindingSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PatternBindingSyntax) -> ResultType
   
-  /// Visiting `PostfixIfConfigExprSyntax` specifically.
+  /// Visiting ``PostfixIfConfigExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PostfixIfConfigExprSyntax) -> ResultType
   
-  /// Visiting `PostfixUnaryExprSyntax` specifically.
+  /// Visiting ``PostfixUnaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PostfixUnaryExprSyntax) -> ResultType
   
-  /// Visiting `PoundSourceLocationArgsSyntax` specifically.
+  /// Visiting ``PoundSourceLocationArgsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PoundSourceLocationArgsSyntax) -> ResultType
   
-  /// Visiting `PoundSourceLocationSyntax` specifically.
+  /// Visiting ``PoundSourceLocationSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PoundSourceLocationSyntax) -> ResultType
   
-  /// Visiting `PrecedenceGroupAssignmentSyntax` specifically.
+  /// Visiting ``PrecedenceGroupAssignmentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrecedenceGroupAssignmentSyntax) -> ResultType
   
-  /// Visiting `PrecedenceGroupAssociativitySyntax` specifically.
+  /// Visiting ``PrecedenceGroupAssociativitySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrecedenceGroupAssociativitySyntax) -> ResultType
   
-  /// Visiting `PrecedenceGroupAttributeListSyntax` specifically.
+  /// Visiting ``PrecedenceGroupAttributeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrecedenceGroupAttributeListSyntax) -> ResultType
   
-  /// Visiting `PrecedenceGroupDeclSyntax` specifically.
+  /// Visiting ``PrecedenceGroupDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrecedenceGroupDeclSyntax) -> ResultType
   
-  /// Visiting `PrecedenceGroupNameElementSyntax` specifically.
+  /// Visiting ``PrecedenceGroupNameElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrecedenceGroupNameElementSyntax) -> ResultType
   
-  /// Visiting `PrecedenceGroupNameListSyntax` specifically.
+  /// Visiting ``PrecedenceGroupNameListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrecedenceGroupNameListSyntax) -> ResultType
   
-  /// Visiting `PrecedenceGroupRelationSyntax` specifically.
+  /// Visiting ``PrecedenceGroupRelationSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrecedenceGroupRelationSyntax) -> ResultType
   
-  /// Visiting `PrefixOperatorExprSyntax` specifically.
+  /// Visiting ``PrefixOperatorExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrefixOperatorExprSyntax) -> ResultType
   
-  /// Visiting `PrimaryAssociatedTypeClauseSyntax` specifically.
+  /// Visiting ``PrimaryAssociatedTypeClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrimaryAssociatedTypeClauseSyntax) -> ResultType
   
-  /// Visiting `PrimaryAssociatedTypeListSyntax` specifically.
+  /// Visiting ``PrimaryAssociatedTypeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrimaryAssociatedTypeListSyntax) -> ResultType
   
-  /// Visiting `PrimaryAssociatedTypeSyntax` specifically.
+  /// Visiting ``PrimaryAssociatedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: PrimaryAssociatedTypeSyntax) -> ResultType
   
-  /// Visiting `ProtocolDeclSyntax` specifically.
+  /// Visiting ``ProtocolDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ProtocolDeclSyntax) -> ResultType
   
-  /// Visiting `QualifiedDeclNameSyntax` specifically.
+  /// Visiting ``QualifiedDeclNameSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: QualifiedDeclNameSyntax) -> ResultType
   
-  /// Visiting `RegexLiteralExprSyntax` specifically.
+  /// Visiting ``RegexLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: RegexLiteralExprSyntax) -> ResultType
   
-  /// Visiting `RepeatWhileStmtSyntax` specifically.
+  /// Visiting ``RepeatWhileStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: RepeatWhileStmtSyntax) -> ResultType
   
-  /// Visiting `ReturnClauseSyntax` specifically.
+  /// Visiting ``ReturnClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ReturnClauseSyntax) -> ResultType
   
-  /// Visiting `ReturnStmtSyntax` specifically.
+  /// Visiting ``ReturnStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ReturnStmtSyntax) -> ResultType
   
-  /// Visiting `SameTypeRequirementSyntax` specifically.
+  /// Visiting ``SameTypeRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SameTypeRequirementSyntax) -> ResultType
   
-  /// Visiting `SequenceExprSyntax` specifically.
+  /// Visiting ``SequenceExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SequenceExprSyntax) -> ResultType
   
-  /// Visiting `SimpleTypeIdentifierSyntax` specifically.
+  /// Visiting ``SimpleTypeIdentifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SimpleTypeIdentifierSyntax) -> ResultType
   
-  /// Visiting `SourceFileSyntax` specifically.
+  /// Visiting ``SourceFileSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SourceFileSyntax) -> ResultType
   
-  /// Visiting `SpecializeAttributeSpecListSyntax` specifically.
+  /// Visiting ``SpecializeAttributeSpecListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SpecializeAttributeSpecListSyntax) -> ResultType
   
-  /// Visiting `SpecializeExprSyntax` specifically.
+  /// Visiting ``SpecializeExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SpecializeExprSyntax) -> ResultType
   
-  /// Visiting `StringLiteralExprSyntax` specifically.
+  /// Visiting ``StringLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: StringLiteralExprSyntax) -> ResultType
   
-  /// Visiting `StringLiteralSegmentsSyntax` specifically.
+  /// Visiting ``StringLiteralSegmentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: StringLiteralSegmentsSyntax) -> ResultType
   
-  /// Visiting `StringSegmentSyntax` specifically.
+  /// Visiting ``StringSegmentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: StringSegmentSyntax) -> ResultType
   
-  /// Visiting `StructDeclSyntax` specifically.
+  /// Visiting ``StructDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: StructDeclSyntax) -> ResultType
   
-  /// Visiting `SubscriptDeclSyntax` specifically.
+  /// Visiting ``SubscriptDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SubscriptDeclSyntax) -> ResultType
   
-  /// Visiting `SubscriptExprSyntax` specifically.
+  /// Visiting ``SubscriptExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SubscriptExprSyntax) -> ResultType
   
-  /// Visiting `SuperRefExprSyntax` specifically.
+  /// Visiting ``SuperRefExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SuperRefExprSyntax) -> ResultType
   
-  /// Visiting `SuppressedTypeSyntax` specifically.
+  /// Visiting ``SuppressedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SuppressedTypeSyntax) -> ResultType
   
-  /// Visiting `SwitchCaseLabelSyntax` specifically.
+  /// Visiting ``SwitchCaseLabelSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SwitchCaseLabelSyntax) -> ResultType
   
-  /// Visiting `SwitchCaseListSyntax` specifically.
+  /// Visiting ``SwitchCaseListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SwitchCaseListSyntax) -> ResultType
   
-  /// Visiting `SwitchCaseSyntax` specifically.
+  /// Visiting ``SwitchCaseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SwitchCaseSyntax) -> ResultType
   
-  /// Visiting `SwitchDefaultLabelSyntax` specifically.
+  /// Visiting ``SwitchDefaultLabelSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SwitchDefaultLabelSyntax) -> ResultType
   
-  /// Visiting `SwitchExprSyntax` specifically.
+  /// Visiting ``SwitchExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: SwitchExprSyntax) -> ResultType
   
-  /// Visiting `TargetFunctionEntrySyntax` specifically.
+  /// Visiting ``TargetFunctionEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TargetFunctionEntrySyntax) -> ResultType
   
-  /// Visiting `TernaryExprSyntax` specifically.
+  /// Visiting ``TernaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TernaryExprSyntax) -> ResultType
   
-  /// Visiting `ThrowStmtSyntax` specifically.
+  /// Visiting ``ThrowStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ThrowStmtSyntax) -> ResultType
   
-  /// Visiting `TryExprSyntax` specifically.
+  /// Visiting ``TryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TryExprSyntax) -> ResultType
   
-  /// Visiting `TupleExprElementListSyntax` specifically.
+  /// Visiting ``TupleExprElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TupleExprElementListSyntax) -> ResultType
   
-  /// Visiting `TupleExprElementSyntax` specifically.
+  /// Visiting ``TupleExprElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TupleExprElementSyntax) -> ResultType
   
-  /// Visiting `TupleExprSyntax` specifically.
+  /// Visiting ``TupleExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TupleExprSyntax) -> ResultType
   
-  /// Visiting `TuplePatternElementListSyntax` specifically.
+  /// Visiting ``TuplePatternElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TuplePatternElementListSyntax) -> ResultType
   
-  /// Visiting `TuplePatternElementSyntax` specifically.
+  /// Visiting ``TuplePatternElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TuplePatternElementSyntax) -> ResultType
   
-  /// Visiting `TuplePatternSyntax` specifically.
+  /// Visiting ``TuplePatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TuplePatternSyntax) -> ResultType
   
-  /// Visiting `TupleTypeElementListSyntax` specifically.
+  /// Visiting ``TupleTypeElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TupleTypeElementListSyntax) -> ResultType
   
-  /// Visiting `TupleTypeElementSyntax` specifically.
+  /// Visiting ``TupleTypeElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TupleTypeElementSyntax) -> ResultType
   
-  /// Visiting `TupleTypeSyntax` specifically.
+  /// Visiting ``TupleTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TupleTypeSyntax) -> ResultType
   
-  /// Visiting `TypeAnnotationSyntax` specifically.
+  /// Visiting ``TypeAnnotationSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TypeAnnotationSyntax) -> ResultType
   
-  /// Visiting `TypeEffectSpecifiersSyntax` specifically.
+  /// Visiting ``TypeEffectSpecifiersSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TypeEffectSpecifiersSyntax) -> ResultType
   
-  /// Visiting `TypeExprSyntax` specifically.
+  /// Visiting ``TypeExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TypeExprSyntax) -> ResultType
   
-  /// Visiting `TypeInheritanceClauseSyntax` specifically.
+  /// Visiting ``TypeInheritanceClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TypeInheritanceClauseSyntax) -> ResultType
   
-  /// Visiting `TypeInitializerClauseSyntax` specifically.
+  /// Visiting ``TypeInitializerClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TypeInitializerClauseSyntax) -> ResultType
   
-  /// Visiting `TypealiasDeclSyntax` specifically.
+  /// Visiting ``TypealiasDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TypealiasDeclSyntax) -> ResultType
   
-  /// Visiting `UnavailableFromAsyncArgumentsSyntax` specifically.
+  /// Visiting ``UnavailableFromAsyncArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: UnavailableFromAsyncArgumentsSyntax) -> ResultType
   
-  /// Visiting `UnderscorePrivateAttributeArgumentsSyntax` specifically.
+  /// Visiting ``UnderscorePrivateAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: UnderscorePrivateAttributeArgumentsSyntax) -> ResultType
   
-  /// Visiting `UnexpectedNodesSyntax` specifically.
+  /// Visiting ``UnexpectedNodesSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: UnexpectedNodesSyntax) -> ResultType
   
-  /// Visiting `UnresolvedAsExprSyntax` specifically.
+  /// Visiting ``UnresolvedAsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: UnresolvedAsExprSyntax) -> ResultType
   
-  /// Visiting `UnresolvedIsExprSyntax` specifically.
+  /// Visiting ``UnresolvedIsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: UnresolvedIsExprSyntax) -> ResultType
   
-  /// Visiting `UnresolvedPatternExprSyntax` specifically.
+  /// Visiting ``UnresolvedPatternExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: UnresolvedPatternExprSyntax) -> ResultType
   
-  /// Visiting `UnresolvedTernaryExprSyntax` specifically.
+  /// Visiting ``UnresolvedTernaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: UnresolvedTernaryExprSyntax) -> ResultType
   
-  /// Visiting `ValueBindingPatternSyntax` specifically.
+  /// Visiting ``ValueBindingPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ValueBindingPatternSyntax) -> ResultType
   
-  /// Visiting `VariableDeclSyntax` specifically.
+  /// Visiting ``VariableDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: VariableDeclSyntax) -> ResultType
   
-  /// Visiting `VersionComponentListSyntax` specifically.
+  /// Visiting ``VersionComponentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: VersionComponentListSyntax) -> ResultType
   
-  /// Visiting `VersionComponentSyntax` specifically.
+  /// Visiting ``VersionComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: VersionComponentSyntax) -> ResultType
   
-  /// Visiting `VersionTupleSyntax` specifically.
+  /// Visiting ``VersionTupleSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: VersionTupleSyntax) -> ResultType
   
-  /// Visiting `WhereClauseSyntax` specifically.
+  /// Visiting ``WhereClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: WhereClauseSyntax) -> ResultType
   
-  /// Visiting `WhileStmtSyntax` specifically.
+  /// Visiting ``WhileStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: WhileStmtSyntax) -> ResultType
   
-  /// Visiting `WildcardPatternSyntax` specifically.
+  /// Visiting ``WildcardPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: WildcardPatternSyntax) -> ResultType
   
-  /// Visiting `YieldExprListElementSyntax` specifically.
+  /// Visiting ``YieldExprListElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: YieldExprListElementSyntax) -> ResultType
   
-  /// Visiting `YieldExprListSyntax` specifically.
+  /// Visiting ``YieldExprListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: YieldExprListSyntax) -> ResultType
   
-  /// Visiting `YieldListSyntax` specifically.
+  /// Visiting ``YieldListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: YieldListSyntax) -> ResultType
   
-  /// Visiting `YieldStmtSyntax` specifically.
+  /// Visiting ``YieldStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: YieldStmtSyntax) -> ResultType
@@ -1395,1918 +1395,1918 @@ extension SyntaxTransformVisitor {
     visitAny(Syntax(token))
   }
   
-  /// Visiting `AccessorBlockSyntax` specifically.
+  /// Visiting ``AccessorBlockSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AccessorBlockSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AccessorDeclSyntax` specifically.
+  /// Visiting ``AccessorDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AccessorDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AccessorEffectSpecifiersSyntax` specifically.
+  /// Visiting ``AccessorEffectSpecifiersSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AccessorEffectSpecifiersSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AccessorListSyntax` specifically.
+  /// Visiting ``AccessorListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AccessorListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AccessorParameterSyntax` specifically.
+  /// Visiting ``AccessorParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AccessorParameterSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ActorDeclSyntax` specifically.
+  /// Visiting ``ActorDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ActorDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ArrayElementListSyntax` specifically.
+  /// Visiting ``ArrayElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ArrayElementListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ArrayElementSyntax` specifically.
+  /// Visiting ``ArrayElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ArrayElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ArrayExprSyntax` specifically.
+  /// Visiting ``ArrayExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ArrayExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ArrayTypeSyntax` specifically.
+  /// Visiting ``ArrayTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ArrayTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ArrowExprSyntax` specifically.
+  /// Visiting ``ArrowExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ArrowExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AsExprSyntax` specifically.
+  /// Visiting ``AsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AsExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AssignmentExprSyntax` specifically.
+  /// Visiting ``AssignmentExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AssignmentExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AssociatedtypeDeclSyntax` specifically.
+  /// Visiting ``AssociatedtypeDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AssociatedtypeDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AttributeListSyntax` specifically.
+  /// Visiting ``AttributeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AttributeListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AttributeSyntax` specifically.
+  /// Visiting ``AttributeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AttributeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AttributedTypeSyntax` specifically.
+  /// Visiting ``AttributedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AttributedTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AvailabilityArgumentSyntax` specifically.
+  /// Visiting ``AvailabilityArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AvailabilityArgumentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AvailabilityConditionSyntax` specifically.
+  /// Visiting ``AvailabilityConditionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AvailabilityConditionSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AvailabilityEntrySyntax` specifically.
+  /// Visiting ``AvailabilityEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AvailabilityEntrySyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AvailabilityLabeledArgumentSyntax` specifically.
+  /// Visiting ``AvailabilityLabeledArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AvailabilityLabeledArgumentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AvailabilitySpecListSyntax` specifically.
+  /// Visiting ``AvailabilitySpecListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AvailabilitySpecListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AvailabilityVersionRestrictionListEntrySyntax` specifically.
+  /// Visiting ``AvailabilityVersionRestrictionListEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AvailabilityVersionRestrictionListEntrySyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AvailabilityVersionRestrictionListSyntax` specifically.
+  /// Visiting ``AvailabilityVersionRestrictionListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AvailabilityVersionRestrictionListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AvailabilityVersionRestrictionSyntax` specifically.
+  /// Visiting ``AvailabilityVersionRestrictionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AvailabilityVersionRestrictionSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `AwaitExprSyntax` specifically.
+  /// Visiting ``AwaitExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: AwaitExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `BackDeployedAttributeSpecListSyntax` specifically.
+  /// Visiting ``BackDeployedAttributeSpecListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: BackDeployedAttributeSpecListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `BinaryOperatorExprSyntax` specifically.
+  /// Visiting ``BinaryOperatorExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: BinaryOperatorExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `BooleanLiteralExprSyntax` specifically.
+  /// Visiting ``BooleanLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: BooleanLiteralExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `BorrowExprSyntax` specifically.
+  /// Visiting ``BorrowExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: BorrowExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `BreakStmtSyntax` specifically.
+  /// Visiting ``BreakStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: BreakStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CanImportExprSyntax` specifically.
+  /// Visiting ``CanImportExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CanImportExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CanImportVersionInfoSyntax` specifically.
+  /// Visiting ``CanImportVersionInfoSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CanImportVersionInfoSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CaseItemListSyntax` specifically.
+  /// Visiting ``CaseItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CaseItemListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CaseItemSyntax` specifically.
+  /// Visiting ``CaseItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CaseItemSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CatchClauseListSyntax` specifically.
+  /// Visiting ``CatchClauseListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CatchClauseListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CatchClauseSyntax` specifically.
+  /// Visiting ``CatchClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CatchClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CatchItemListSyntax` specifically.
+  /// Visiting ``CatchItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CatchItemListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CatchItemSyntax` specifically.
+  /// Visiting ``CatchItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CatchItemSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClassDeclSyntax` specifically.
+  /// Visiting ``ClassDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClassDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClassRestrictionTypeSyntax` specifically.
+  /// Visiting ``ClassRestrictionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClassRestrictionTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureCaptureItemListSyntax` specifically.
+  /// Visiting ``ClosureCaptureItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureCaptureItemListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureCaptureItemSpecifierSyntax` specifically.
+  /// Visiting ``ClosureCaptureItemSpecifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureCaptureItemSpecifierSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureCaptureItemSyntax` specifically.
+  /// Visiting ``ClosureCaptureItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureCaptureItemSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureCaptureSignatureSyntax` specifically.
+  /// Visiting ``ClosureCaptureSignatureSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureCaptureSignatureSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureExprSyntax` specifically.
+  /// Visiting ``ClosureExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureParamListSyntax` specifically.
+  /// Visiting ``ClosureParamListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureParamListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureParamSyntax` specifically.
+  /// Visiting ``ClosureParamSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureParamSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureParameterClauseSyntax` specifically.
+  /// Visiting ``ClosureParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureParameterClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureParameterListSyntax` specifically.
+  /// Visiting ``ClosureParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureParameterListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureParameterSyntax` specifically.
+  /// Visiting ``ClosureParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureParameterSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ClosureSignatureSyntax` specifically.
+  /// Visiting ``ClosureSignatureSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ClosureSignatureSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CodeBlockItemListSyntax` specifically.
+  /// Visiting ``CodeBlockItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CodeBlockItemListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CodeBlockItemSyntax` specifically.
+  /// Visiting ``CodeBlockItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CodeBlockItemSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CodeBlockSyntax` specifically.
+  /// Visiting ``CodeBlockSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CodeBlockSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CompositionTypeElementListSyntax` specifically.
+  /// Visiting ``CompositionTypeElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CompositionTypeElementListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CompositionTypeElementSyntax` specifically.
+  /// Visiting ``CompositionTypeElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CompositionTypeElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CompositionTypeSyntax` specifically.
+  /// Visiting ``CompositionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CompositionTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ConditionElementListSyntax` specifically.
+  /// Visiting ``ConditionElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ConditionElementListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ConditionElementSyntax` specifically.
+  /// Visiting ``ConditionElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ConditionElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ConformanceRequirementSyntax` specifically.
+  /// Visiting ``ConformanceRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ConformanceRequirementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ConstrainedSugarTypeSyntax` specifically.
+  /// Visiting ``ConstrainedSugarTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ConstrainedSugarTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ContinueStmtSyntax` specifically.
+  /// Visiting ``ContinueStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ContinueStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ConventionAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ConventionAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ConventionAttributeArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ConventionWitnessMethodAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ConventionWitnessMethodAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `CopyExprSyntax` specifically.
+  /// Visiting ``CopyExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: CopyExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DeclModifierDetailSyntax` specifically.
+  /// Visiting ``DeclModifierDetailSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DeclModifierDetailSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DeclModifierSyntax` specifically.
+  /// Visiting ``DeclModifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DeclModifierSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DeclNameArgumentListSyntax` specifically.
+  /// Visiting ``DeclNameArgumentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DeclNameArgumentListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DeclNameArgumentSyntax` specifically.
+  /// Visiting ``DeclNameArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DeclNameArgumentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DeclNameArgumentsSyntax` specifically.
+  /// Visiting ``DeclNameArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DeclNameArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DeclNameSyntax` specifically.
+  /// Visiting ``DeclNameSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DeclNameSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DeferStmtSyntax` specifically.
+  /// Visiting ``DeferStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DeferStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DeinitializerDeclSyntax` specifically.
+  /// Visiting ``DeinitializerDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DeinitializerDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DerivativeRegistrationAttributeArgumentsSyntax` specifically.
+  /// Visiting ``DerivativeRegistrationAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DerivativeRegistrationAttributeArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DesignatedTypeElementSyntax` specifically.
+  /// Visiting ``DesignatedTypeElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DesignatedTypeElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DesignatedTypeListSyntax` specifically.
+  /// Visiting ``DesignatedTypeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DesignatedTypeListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DictionaryElementListSyntax` specifically.
+  /// Visiting ``DictionaryElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DictionaryElementListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DictionaryElementSyntax` specifically.
+  /// Visiting ``DictionaryElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DictionaryElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DictionaryExprSyntax` specifically.
+  /// Visiting ``DictionaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DictionaryExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DictionaryTypeSyntax` specifically.
+  /// Visiting ``DictionaryTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DictionaryTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DifferentiabilityParamListSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DifferentiabilityParamListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DifferentiabilityParamSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DifferentiabilityParamSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DifferentiabilityParamsClauseSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamsClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DifferentiabilityParamsClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DifferentiabilityParamsSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DifferentiabilityParamsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DifferentiableAttributeArgumentsSyntax` specifically.
+  /// Visiting ``DifferentiableAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DifferentiableAttributeArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DiscardAssignmentExprSyntax` specifically.
+  /// Visiting ``DiscardAssignmentExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DiscardAssignmentExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DiscardStmtSyntax` specifically.
+  /// Visiting ``DiscardStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DiscardStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DoStmtSyntax` specifically.
+  /// Visiting ``DoStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DoStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DocumentationAttributeArgumentSyntax` specifically.
+  /// Visiting ``DocumentationAttributeArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DocumentationAttributeArgumentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DocumentationAttributeArgumentsSyntax` specifically.
+  /// Visiting ``DocumentationAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DocumentationAttributeArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `DynamicReplacementArgumentsSyntax` specifically.
+  /// Visiting ``DynamicReplacementArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: DynamicReplacementArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `EditorPlaceholderDeclSyntax` specifically.
+  /// Visiting ``EditorPlaceholderDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: EditorPlaceholderDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `EditorPlaceholderExprSyntax` specifically.
+  /// Visiting ``EditorPlaceholderExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: EditorPlaceholderExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `EffectsArgumentsSyntax` specifically.
+  /// Visiting ``EffectsArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: EffectsArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `EnumCaseDeclSyntax` specifically.
+  /// Visiting ``EnumCaseDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: EnumCaseDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `EnumCaseElementListSyntax` specifically.
+  /// Visiting ``EnumCaseElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: EnumCaseElementListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `EnumCaseElementSyntax` specifically.
+  /// Visiting ``EnumCaseElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: EnumCaseElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `EnumCaseParameterClauseSyntax` specifically.
+  /// Visiting ``EnumCaseParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: EnumCaseParameterClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `EnumCaseParameterListSyntax` specifically.
+  /// Visiting ``EnumCaseParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: EnumCaseParameterListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `EnumCaseParameterSyntax` specifically.
+  /// Visiting ``EnumCaseParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: EnumCaseParameterSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `EnumDeclSyntax` specifically.
+  /// Visiting ``EnumDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: EnumDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ExposeAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ExposeAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ExposeAttributeArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ExprListSyntax` specifically.
+  /// Visiting ``ExprListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ExprListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ExpressionPatternSyntax` specifically.
+  /// Visiting ``ExpressionPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ExpressionPatternSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ExpressionSegmentSyntax` specifically.
+  /// Visiting ``ExpressionSegmentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ExpressionSegmentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ExpressionStmtSyntax` specifically.
+  /// Visiting ``ExpressionStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ExpressionStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ExtensionDeclSyntax` specifically.
+  /// Visiting ``ExtensionDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ExtensionDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `FallthroughStmtSyntax` specifically.
+  /// Visiting ``FallthroughStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: FallthroughStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `FloatLiteralExprSyntax` specifically.
+  /// Visiting ``FloatLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: FloatLiteralExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ForInStmtSyntax` specifically.
+  /// Visiting ``ForInStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ForInStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ForcedValueExprSyntax` specifically.
+  /// Visiting ``ForcedValueExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ForcedValueExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `FunctionCallExprSyntax` specifically.
+  /// Visiting ``FunctionCallExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: FunctionCallExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `FunctionDeclSyntax` specifically.
+  /// Visiting ``FunctionDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: FunctionDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `FunctionEffectSpecifiersSyntax` specifically.
+  /// Visiting ``FunctionEffectSpecifiersSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: FunctionEffectSpecifiersSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `FunctionParameterListSyntax` specifically.
+  /// Visiting ``FunctionParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: FunctionParameterListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `FunctionParameterSyntax` specifically.
+  /// Visiting ``FunctionParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: FunctionParameterSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `FunctionSignatureSyntax` specifically.
+  /// Visiting ``FunctionSignatureSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: FunctionSignatureSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `FunctionTypeSyntax` specifically.
+  /// Visiting ``FunctionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: FunctionTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `GenericArgumentClauseSyntax` specifically.
+  /// Visiting ``GenericArgumentClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: GenericArgumentClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `GenericArgumentListSyntax` specifically.
+  /// Visiting ``GenericArgumentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: GenericArgumentListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `GenericArgumentSyntax` specifically.
+  /// Visiting ``GenericArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: GenericArgumentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `GenericParameterClauseSyntax` specifically.
+  /// Visiting ``GenericParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: GenericParameterClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `GenericParameterListSyntax` specifically.
+  /// Visiting ``GenericParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: GenericParameterListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `GenericParameterSyntax` specifically.
+  /// Visiting ``GenericParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: GenericParameterSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `GenericRequirementListSyntax` specifically.
+  /// Visiting ``GenericRequirementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: GenericRequirementListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `GenericRequirementSyntax` specifically.
+  /// Visiting ``GenericRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: GenericRequirementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `GenericWhereClauseSyntax` specifically.
+  /// Visiting ``GenericWhereClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: GenericWhereClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `GuardStmtSyntax` specifically.
+  /// Visiting ``GuardStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: GuardStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `IdentifierExprSyntax` specifically.
+  /// Visiting ``IdentifierExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: IdentifierExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `IdentifierPatternSyntax` specifically.
+  /// Visiting ``IdentifierPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: IdentifierPatternSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `IfConfigClauseListSyntax` specifically.
+  /// Visiting ``IfConfigClauseListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: IfConfigClauseListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `IfConfigClauseSyntax` specifically.
+  /// Visiting ``IfConfigClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: IfConfigClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `IfConfigDeclSyntax` specifically.
+  /// Visiting ``IfConfigDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: IfConfigDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `IfExprSyntax` specifically.
+  /// Visiting ``IfExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: IfExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ImplementsAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ImplementsAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ImplementsAttributeArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ImplicitlyUnwrappedOptionalTypeSyntax` specifically.
+  /// Visiting ``ImplicitlyUnwrappedOptionalTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ImplicitlyUnwrappedOptionalTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ImportDeclSyntax` specifically.
+  /// Visiting ``ImportDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ImportDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ImportPathComponentSyntax` specifically.
+  /// Visiting ``ImportPathComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ImportPathComponentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ImportPathSyntax` specifically.
+  /// Visiting ``ImportPathSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ImportPathSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `InOutExprSyntax` specifically.
+  /// Visiting ``InOutExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: InOutExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `InfixOperatorExprSyntax` specifically.
+  /// Visiting ``InfixOperatorExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: InfixOperatorExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `InheritedTypeListSyntax` specifically.
+  /// Visiting ``InheritedTypeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: InheritedTypeListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `InheritedTypeSyntax` specifically.
+  /// Visiting ``InheritedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: InheritedTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `InitializerClauseSyntax` specifically.
+  /// Visiting ``InitializerClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: InitializerClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `InitializerDeclSyntax` specifically.
+  /// Visiting ``InitializerDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: InitializerDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `IntegerLiteralExprSyntax` specifically.
+  /// Visiting ``IntegerLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: IntegerLiteralExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `IsExprSyntax` specifically.
+  /// Visiting ``IsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: IsExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `IsTypePatternSyntax` specifically.
+  /// Visiting ``IsTypePatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: IsTypePatternSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `KeyPathComponentListSyntax` specifically.
+  /// Visiting ``KeyPathComponentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: KeyPathComponentListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `KeyPathComponentSyntax` specifically.
+  /// Visiting ``KeyPathComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: KeyPathComponentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `KeyPathExprSyntax` specifically.
+  /// Visiting ``KeyPathExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: KeyPathExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `KeyPathOptionalComponentSyntax` specifically.
+  /// Visiting ``KeyPathOptionalComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: KeyPathOptionalComponentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `KeyPathPropertyComponentSyntax` specifically.
+  /// Visiting ``KeyPathPropertyComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: KeyPathPropertyComponentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `KeyPathSubscriptComponentSyntax` specifically.
+  /// Visiting ``KeyPathSubscriptComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: KeyPathSubscriptComponentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `LabeledSpecializeEntrySyntax` specifically.
+  /// Visiting ``LabeledSpecializeEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: LabeledSpecializeEntrySyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `LabeledStmtSyntax` specifically.
+  /// Visiting ``LabeledStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: LabeledStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `LayoutRequirementSyntax` specifically.
+  /// Visiting ``LayoutRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: LayoutRequirementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MacroDeclSyntax` specifically.
+  /// Visiting ``MacroDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MacroDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MacroExpansionDeclSyntax` specifically.
+  /// Visiting ``MacroExpansionDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MacroExpansionDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MacroExpansionExprSyntax` specifically.
+  /// Visiting ``MacroExpansionExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MacroExpansionExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MatchingPatternConditionSyntax` specifically.
+  /// Visiting ``MatchingPatternConditionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MatchingPatternConditionSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MemberAccessExprSyntax` specifically.
+  /// Visiting ``MemberAccessExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MemberAccessExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MemberDeclBlockSyntax` specifically.
+  /// Visiting ``MemberDeclBlockSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MemberDeclBlockSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MemberDeclListItemSyntax` specifically.
+  /// Visiting ``MemberDeclListItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MemberDeclListItemSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MemberDeclListSyntax` specifically.
+  /// Visiting ``MemberDeclListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MemberDeclListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MemberTypeIdentifierSyntax` specifically.
+  /// Visiting ``MemberTypeIdentifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MemberTypeIdentifierSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MetatypeTypeSyntax` specifically.
+  /// Visiting ``MetatypeTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MetatypeTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MissingDeclSyntax` specifically.
+  /// Visiting ``MissingDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MissingDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MissingExprSyntax` specifically.
+  /// Visiting ``MissingExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MissingExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MissingPatternSyntax` specifically.
+  /// Visiting ``MissingPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MissingPatternSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MissingStmtSyntax` specifically.
+  /// Visiting ``MissingStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MissingStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MissingSyntax` specifically.
+  /// Visiting ``MissingSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MissingSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MissingTypeSyntax` specifically.
+  /// Visiting ``MissingTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MissingTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ModifierListSyntax` specifically.
+  /// Visiting ``ModifierListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ModifierListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MoveExprSyntax` specifically.
+  /// Visiting ``MoveExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MoveExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MultipleTrailingClosureElementListSyntax` specifically.
+  /// Visiting ``MultipleTrailingClosureElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MultipleTrailingClosureElementListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `MultipleTrailingClosureElementSyntax` specifically.
+  /// Visiting ``MultipleTrailingClosureElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: MultipleTrailingClosureElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `NamedOpaqueReturnTypeSyntax` specifically.
+  /// Visiting ``NamedOpaqueReturnTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: NamedOpaqueReturnTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `NilLiteralExprSyntax` specifically.
+  /// Visiting ``NilLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: NilLiteralExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ObjCSelectorPieceSyntax` specifically.
+  /// Visiting ``ObjCSelectorPieceSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ObjCSelectorPieceSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ObjCSelectorSyntax` specifically.
+  /// Visiting ``ObjCSelectorSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ObjCSelectorSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `OpaqueReturnTypeOfAttributeArgumentsSyntax` specifically.
+  /// Visiting ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `OperatorDeclSyntax` specifically.
+  /// Visiting ``OperatorDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: OperatorDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `OperatorPrecedenceAndTypesSyntax` specifically.
+  /// Visiting ``OperatorPrecedenceAndTypesSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: OperatorPrecedenceAndTypesSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `OptionalBindingConditionSyntax` specifically.
+  /// Visiting ``OptionalBindingConditionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: OptionalBindingConditionSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `OptionalChainingExprSyntax` specifically.
+  /// Visiting ``OptionalChainingExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: OptionalChainingExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `OptionalTypeSyntax` specifically.
+  /// Visiting ``OptionalTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: OptionalTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `OriginallyDefinedInArgumentsSyntax` specifically.
+  /// Visiting ``OriginallyDefinedInArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: OriginallyDefinedInArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PackElementExprSyntax` specifically.
+  /// Visiting ``PackElementExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PackElementExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PackExpansionExprSyntax` specifically.
+  /// Visiting ``PackExpansionExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PackExpansionExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PackExpansionTypeSyntax` specifically.
+  /// Visiting ``PackExpansionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PackExpansionTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PackReferenceTypeSyntax` specifically.
+  /// Visiting ``PackReferenceTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PackReferenceTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ParameterClauseSyntax` specifically.
+  /// Visiting ``ParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ParameterClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PatternBindingListSyntax` specifically.
+  /// Visiting ``PatternBindingListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PatternBindingListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PatternBindingSyntax` specifically.
+  /// Visiting ``PatternBindingSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PatternBindingSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PostfixIfConfigExprSyntax` specifically.
+  /// Visiting ``PostfixIfConfigExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PostfixIfConfigExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PostfixUnaryExprSyntax` specifically.
+  /// Visiting ``PostfixUnaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PostfixUnaryExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PoundSourceLocationArgsSyntax` specifically.
+  /// Visiting ``PoundSourceLocationArgsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PoundSourceLocationArgsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PoundSourceLocationSyntax` specifically.
+  /// Visiting ``PoundSourceLocationSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PoundSourceLocationSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrecedenceGroupAssignmentSyntax` specifically.
+  /// Visiting ``PrecedenceGroupAssignmentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrecedenceGroupAssignmentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrecedenceGroupAssociativitySyntax` specifically.
+  /// Visiting ``PrecedenceGroupAssociativitySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrecedenceGroupAssociativitySyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrecedenceGroupAttributeListSyntax` specifically.
+  /// Visiting ``PrecedenceGroupAttributeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrecedenceGroupAttributeListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrecedenceGroupDeclSyntax` specifically.
+  /// Visiting ``PrecedenceGroupDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrecedenceGroupDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrecedenceGroupNameElementSyntax` specifically.
+  /// Visiting ``PrecedenceGroupNameElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrecedenceGroupNameElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrecedenceGroupNameListSyntax` specifically.
+  /// Visiting ``PrecedenceGroupNameListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrecedenceGroupNameListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrecedenceGroupRelationSyntax` specifically.
+  /// Visiting ``PrecedenceGroupRelationSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrecedenceGroupRelationSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrefixOperatorExprSyntax` specifically.
+  /// Visiting ``PrefixOperatorExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrefixOperatorExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrimaryAssociatedTypeClauseSyntax` specifically.
+  /// Visiting ``PrimaryAssociatedTypeClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrimaryAssociatedTypeClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrimaryAssociatedTypeListSyntax` specifically.
+  /// Visiting ``PrimaryAssociatedTypeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrimaryAssociatedTypeListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `PrimaryAssociatedTypeSyntax` specifically.
+  /// Visiting ``PrimaryAssociatedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: PrimaryAssociatedTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ProtocolDeclSyntax` specifically.
+  /// Visiting ``ProtocolDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ProtocolDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `QualifiedDeclNameSyntax` specifically.
+  /// Visiting ``QualifiedDeclNameSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: QualifiedDeclNameSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `RegexLiteralExprSyntax` specifically.
+  /// Visiting ``RegexLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: RegexLiteralExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `RepeatWhileStmtSyntax` specifically.
+  /// Visiting ``RepeatWhileStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: RepeatWhileStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ReturnClauseSyntax` specifically.
+  /// Visiting ``ReturnClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ReturnClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ReturnStmtSyntax` specifically.
+  /// Visiting ``ReturnStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ReturnStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SameTypeRequirementSyntax` specifically.
+  /// Visiting ``SameTypeRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SameTypeRequirementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SequenceExprSyntax` specifically.
+  /// Visiting ``SequenceExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SequenceExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SimpleTypeIdentifierSyntax` specifically.
+  /// Visiting ``SimpleTypeIdentifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SimpleTypeIdentifierSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SourceFileSyntax` specifically.
+  /// Visiting ``SourceFileSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SourceFileSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SpecializeAttributeSpecListSyntax` specifically.
+  /// Visiting ``SpecializeAttributeSpecListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SpecializeAttributeSpecListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SpecializeExprSyntax` specifically.
+  /// Visiting ``SpecializeExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SpecializeExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `StringLiteralExprSyntax` specifically.
+  /// Visiting ``StringLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: StringLiteralExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `StringLiteralSegmentsSyntax` specifically.
+  /// Visiting ``StringLiteralSegmentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: StringLiteralSegmentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `StringSegmentSyntax` specifically.
+  /// Visiting ``StringSegmentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: StringSegmentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `StructDeclSyntax` specifically.
+  /// Visiting ``StructDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: StructDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SubscriptDeclSyntax` specifically.
+  /// Visiting ``SubscriptDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SubscriptDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SubscriptExprSyntax` specifically.
+  /// Visiting ``SubscriptExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SubscriptExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SuperRefExprSyntax` specifically.
+  /// Visiting ``SuperRefExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SuperRefExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SuppressedTypeSyntax` specifically.
+  /// Visiting ``SuppressedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SuppressedTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SwitchCaseLabelSyntax` specifically.
+  /// Visiting ``SwitchCaseLabelSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SwitchCaseLabelSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SwitchCaseListSyntax` specifically.
+  /// Visiting ``SwitchCaseListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SwitchCaseListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SwitchCaseSyntax` specifically.
+  /// Visiting ``SwitchCaseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SwitchCaseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SwitchDefaultLabelSyntax` specifically.
+  /// Visiting ``SwitchDefaultLabelSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SwitchDefaultLabelSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `SwitchExprSyntax` specifically.
+  /// Visiting ``SwitchExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: SwitchExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TargetFunctionEntrySyntax` specifically.
+  /// Visiting ``TargetFunctionEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TargetFunctionEntrySyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TernaryExprSyntax` specifically.
+  /// Visiting ``TernaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TernaryExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ThrowStmtSyntax` specifically.
+  /// Visiting ``ThrowStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ThrowStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TryExprSyntax` specifically.
+  /// Visiting ``TryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TryExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TupleExprElementListSyntax` specifically.
+  /// Visiting ``TupleExprElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TupleExprElementListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TupleExprElementSyntax` specifically.
+  /// Visiting ``TupleExprElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TupleExprElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TupleExprSyntax` specifically.
+  /// Visiting ``TupleExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TupleExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TuplePatternElementListSyntax` specifically.
+  /// Visiting ``TuplePatternElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TuplePatternElementListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TuplePatternElementSyntax` specifically.
+  /// Visiting ``TuplePatternElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TuplePatternElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TuplePatternSyntax` specifically.
+  /// Visiting ``TuplePatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TuplePatternSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TupleTypeElementListSyntax` specifically.
+  /// Visiting ``TupleTypeElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TupleTypeElementListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TupleTypeElementSyntax` specifically.
+  /// Visiting ``TupleTypeElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TupleTypeElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TupleTypeSyntax` specifically.
+  /// Visiting ``TupleTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TupleTypeSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TypeAnnotationSyntax` specifically.
+  /// Visiting ``TypeAnnotationSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TypeAnnotationSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TypeEffectSpecifiersSyntax` specifically.
+  /// Visiting ``TypeEffectSpecifiersSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TypeEffectSpecifiersSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TypeExprSyntax` specifically.
+  /// Visiting ``TypeExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TypeExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TypeInheritanceClauseSyntax` specifically.
+  /// Visiting ``TypeInheritanceClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TypeInheritanceClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TypeInitializerClauseSyntax` specifically.
+  /// Visiting ``TypeInitializerClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TypeInitializerClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `TypealiasDeclSyntax` specifically.
+  /// Visiting ``TypealiasDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: TypealiasDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `UnavailableFromAsyncArgumentsSyntax` specifically.
+  /// Visiting ``UnavailableFromAsyncArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: UnavailableFromAsyncArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `UnderscorePrivateAttributeArgumentsSyntax` specifically.
+  /// Visiting ``UnderscorePrivateAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: UnderscorePrivateAttributeArgumentsSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `UnexpectedNodesSyntax` specifically.
+  /// Visiting ``UnexpectedNodesSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: UnexpectedNodesSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `UnresolvedAsExprSyntax` specifically.
+  /// Visiting ``UnresolvedAsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: UnresolvedAsExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `UnresolvedIsExprSyntax` specifically.
+  /// Visiting ``UnresolvedIsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: UnresolvedIsExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `UnresolvedPatternExprSyntax` specifically.
+  /// Visiting ``UnresolvedPatternExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: UnresolvedPatternExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `UnresolvedTernaryExprSyntax` specifically.
+  /// Visiting ``UnresolvedTernaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: UnresolvedTernaryExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `ValueBindingPatternSyntax` specifically.
+  /// Visiting ``ValueBindingPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: ValueBindingPatternSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `VariableDeclSyntax` specifically.
+  /// Visiting ``VariableDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: VariableDeclSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `VersionComponentListSyntax` specifically.
+  /// Visiting ``VersionComponentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: VersionComponentListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `VersionComponentSyntax` specifically.
+  /// Visiting ``VersionComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: VersionComponentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `VersionTupleSyntax` specifically.
+  /// Visiting ``VersionTupleSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: VersionTupleSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `WhereClauseSyntax` specifically.
+  /// Visiting ``WhereClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: WhereClauseSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `WhileStmtSyntax` specifically.
+  /// Visiting ``WhileStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: WhileStmtSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `WildcardPatternSyntax` specifically.
+  /// Visiting ``WildcardPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: WildcardPatternSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `YieldExprListElementSyntax` specifically.
+  /// Visiting ``YieldExprListElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: YieldExprListElementSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `YieldExprListSyntax` specifically.
+  /// Visiting ``YieldExprListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: YieldExprListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `YieldListSyntax` specifically.
+  /// Visiting ``YieldListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: YieldListSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
   
-  /// Visiting `YieldStmtSyntax` specifically.
+  /// Visiting ``YieldStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
   public func visit(_ node: YieldStmtSyntax) -> ResultType {
diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
index 8d00a1b2d84..fa38af78294 100644
--- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
@@ -34,3295 +34,3295 @@ open class SyntaxVisitor {
     visit(node.data)
   }
   
-  /// Visiting `AccessorBlockSyntax` specifically.
+  /// Visiting ``AccessorBlockSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AccessorBlockSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AccessorBlockSyntax` and its descendents.
+  /// The function called after visiting ``AccessorBlockSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AccessorBlockSyntax) {
   }
   
-  /// Visiting `AccessorDeclSyntax` specifically.
+  /// Visiting ``AccessorDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AccessorDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AccessorDeclSyntax` and its descendents.
+  /// The function called after visiting ``AccessorDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AccessorDeclSyntax) {
   }
   
-  /// Visiting `AccessorEffectSpecifiersSyntax` specifically.
+  /// Visiting ``AccessorEffectSpecifiersSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AccessorEffectSpecifiersSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AccessorEffectSpecifiersSyntax` and its descendents.
+  /// The function called after visiting ``AccessorEffectSpecifiersSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AccessorEffectSpecifiersSyntax) {
   }
   
-  /// Visiting `AccessorListSyntax` specifically.
+  /// Visiting ``AccessorListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AccessorListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AccessorListSyntax` and its descendents.
+  /// The function called after visiting ``AccessorListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AccessorListSyntax) {
   }
   
-  /// Visiting `AccessorParameterSyntax` specifically.
+  /// Visiting ``AccessorParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AccessorParameterSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AccessorParameterSyntax` and its descendents.
+  /// The function called after visiting ``AccessorParameterSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AccessorParameterSyntax) {
   }
   
-  /// Visiting `ActorDeclSyntax` specifically.
+  /// Visiting ``ActorDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ActorDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ActorDeclSyntax` and its descendents.
+  /// The function called after visiting ``ActorDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ActorDeclSyntax) {
   }
   
-  /// Visiting `ArrayElementListSyntax` specifically.
+  /// Visiting ``ArrayElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ArrayElementListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ArrayElementListSyntax` and its descendents.
+  /// The function called after visiting ``ArrayElementListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ArrayElementListSyntax) {
   }
   
-  /// Visiting `ArrayElementSyntax` specifically.
+  /// Visiting ``ArrayElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ArrayElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ArrayElementSyntax` and its descendents.
+  /// The function called after visiting ``ArrayElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ArrayElementSyntax) {
   }
   
-  /// Visiting `ArrayExprSyntax` specifically.
+  /// Visiting ``ArrayExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ArrayExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ArrayExprSyntax` and its descendents.
+  /// The function called after visiting ``ArrayExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ArrayExprSyntax) {
   }
   
-  /// Visiting `ArrayTypeSyntax` specifically.
+  /// Visiting ``ArrayTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ArrayTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ArrayTypeSyntax` and its descendents.
+  /// The function called after visiting ``ArrayTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ArrayTypeSyntax) {
   }
   
-  /// Visiting `ArrowExprSyntax` specifically.
+  /// Visiting ``ArrowExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ArrowExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ArrowExprSyntax` and its descendents.
+  /// The function called after visiting ``ArrowExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ArrowExprSyntax) {
   }
   
-  /// Visiting `AsExprSyntax` specifically.
+  /// Visiting ``AsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AsExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AsExprSyntax` and its descendents.
+  /// The function called after visiting ``AsExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AsExprSyntax) {
   }
   
-  /// Visiting `AssignmentExprSyntax` specifically.
+  /// Visiting ``AssignmentExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AssignmentExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AssignmentExprSyntax` and its descendents.
+  /// The function called after visiting ``AssignmentExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AssignmentExprSyntax) {
   }
   
-  /// Visiting `AssociatedtypeDeclSyntax` specifically.
+  /// Visiting ``AssociatedtypeDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AssociatedtypeDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AssociatedtypeDeclSyntax` and its descendents.
+  /// The function called after visiting ``AssociatedtypeDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AssociatedtypeDeclSyntax) {
   }
   
-  /// Visiting `AttributeListSyntax` specifically.
+  /// Visiting ``AttributeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AttributeListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AttributeListSyntax` and its descendents.
+  /// The function called after visiting ``AttributeListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AttributeListSyntax) {
   }
   
-  /// Visiting `AttributeSyntax` specifically.
+  /// Visiting ``AttributeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AttributeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AttributeSyntax` and its descendents.
+  /// The function called after visiting ``AttributeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AttributeSyntax) {
   }
   
-  /// Visiting `AttributedTypeSyntax` specifically.
+  /// Visiting ``AttributedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AttributedTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AttributedTypeSyntax` and its descendents.
+  /// The function called after visiting ``AttributedTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AttributedTypeSyntax) {
   }
   
-  /// Visiting `AvailabilityArgumentSyntax` specifically.
+  /// Visiting ``AvailabilityArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AvailabilityArgumentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AvailabilityArgumentSyntax` and its descendents.
+  /// The function called after visiting ``AvailabilityArgumentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AvailabilityArgumentSyntax) {
   }
   
-  /// Visiting `AvailabilityConditionSyntax` specifically.
+  /// Visiting ``AvailabilityConditionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AvailabilityConditionSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AvailabilityConditionSyntax` and its descendents.
+  /// The function called after visiting ``AvailabilityConditionSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AvailabilityConditionSyntax) {
   }
   
-  /// Visiting `AvailabilityEntrySyntax` specifically.
+  /// Visiting ``AvailabilityEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AvailabilityEntrySyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AvailabilityEntrySyntax` and its descendents.
+  /// The function called after visiting ``AvailabilityEntrySyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AvailabilityEntrySyntax) {
   }
   
-  /// Visiting `AvailabilityLabeledArgumentSyntax` specifically.
+  /// Visiting ``AvailabilityLabeledArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AvailabilityLabeledArgumentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AvailabilityLabeledArgumentSyntax` and its descendents.
+  /// The function called after visiting ``AvailabilityLabeledArgumentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AvailabilityLabeledArgumentSyntax) {
   }
   
-  /// Visiting `AvailabilitySpecListSyntax` specifically.
+  /// Visiting ``AvailabilitySpecListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AvailabilitySpecListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AvailabilitySpecListSyntax` and its descendents.
+  /// The function called after visiting ``AvailabilitySpecListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AvailabilitySpecListSyntax) {
   }
   
-  /// Visiting `AvailabilityVersionRestrictionListEntrySyntax` specifically.
+  /// Visiting ``AvailabilityVersionRestrictionListEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AvailabilityVersionRestrictionListEntrySyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AvailabilityVersionRestrictionListEntrySyntax` and its descendents.
+  /// The function called after visiting ``AvailabilityVersionRestrictionListEntrySyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AvailabilityVersionRestrictionListEntrySyntax) {
   }
   
-  /// Visiting `AvailabilityVersionRestrictionListSyntax` specifically.
+  /// Visiting ``AvailabilityVersionRestrictionListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AvailabilityVersionRestrictionListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AvailabilityVersionRestrictionListSyntax` and its descendents.
+  /// The function called after visiting ``AvailabilityVersionRestrictionListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AvailabilityVersionRestrictionListSyntax) {
   }
   
-  /// Visiting `AvailabilityVersionRestrictionSyntax` specifically.
+  /// Visiting ``AvailabilityVersionRestrictionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AvailabilityVersionRestrictionSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AvailabilityVersionRestrictionSyntax` and its descendents.
+  /// The function called after visiting ``AvailabilityVersionRestrictionSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AvailabilityVersionRestrictionSyntax) {
   }
   
-  /// Visiting `AwaitExprSyntax` specifically.
+  /// Visiting ``AwaitExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: AwaitExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `AwaitExprSyntax` and its descendents.
+  /// The function called after visiting ``AwaitExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AwaitExprSyntax) {
   }
   
-  /// Visiting `BackDeployedAttributeSpecListSyntax` specifically.
+  /// Visiting ``BackDeployedAttributeSpecListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: BackDeployedAttributeSpecListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `BackDeployedAttributeSpecListSyntax` and its descendents.
+  /// The function called after visiting ``BackDeployedAttributeSpecListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: BackDeployedAttributeSpecListSyntax) {
   }
   
-  /// Visiting `BinaryOperatorExprSyntax` specifically.
+  /// Visiting ``BinaryOperatorExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: BinaryOperatorExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `BinaryOperatorExprSyntax` and its descendents.
+  /// The function called after visiting ``BinaryOperatorExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: BinaryOperatorExprSyntax) {
   }
   
-  /// Visiting `BooleanLiteralExprSyntax` specifically.
+  /// Visiting ``BooleanLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: BooleanLiteralExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `BooleanLiteralExprSyntax` and its descendents.
+  /// The function called after visiting ``BooleanLiteralExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: BooleanLiteralExprSyntax) {
   }
   
-  /// Visiting `BorrowExprSyntax` specifically.
+  /// Visiting ``BorrowExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: BorrowExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `BorrowExprSyntax` and its descendents.
+  /// The function called after visiting ``BorrowExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: BorrowExprSyntax) {
   }
   
-  /// Visiting `BreakStmtSyntax` specifically.
+  /// Visiting ``BreakStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: BreakStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `BreakStmtSyntax` and its descendents.
+  /// The function called after visiting ``BreakStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: BreakStmtSyntax) {
   }
   
-  /// Visiting `CanImportExprSyntax` specifically.
+  /// Visiting ``CanImportExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CanImportExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CanImportExprSyntax` and its descendents.
+  /// The function called after visiting ``CanImportExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CanImportExprSyntax) {
   }
   
-  /// Visiting `CanImportVersionInfoSyntax` specifically.
+  /// Visiting ``CanImportVersionInfoSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CanImportVersionInfoSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CanImportVersionInfoSyntax` and its descendents.
+  /// The function called after visiting ``CanImportVersionInfoSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CanImportVersionInfoSyntax) {
   }
   
-  /// Visiting `CaseItemListSyntax` specifically.
+  /// Visiting ``CaseItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CaseItemListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CaseItemListSyntax` and its descendents.
+  /// The function called after visiting ``CaseItemListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CaseItemListSyntax) {
   }
   
-  /// Visiting `CaseItemSyntax` specifically.
+  /// Visiting ``CaseItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CaseItemSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CaseItemSyntax` and its descendents.
+  /// The function called after visiting ``CaseItemSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CaseItemSyntax) {
   }
   
-  /// Visiting `CatchClauseListSyntax` specifically.
+  /// Visiting ``CatchClauseListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CatchClauseListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CatchClauseListSyntax` and its descendents.
+  /// The function called after visiting ``CatchClauseListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CatchClauseListSyntax) {
   }
   
-  /// Visiting `CatchClauseSyntax` specifically.
+  /// Visiting ``CatchClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CatchClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CatchClauseSyntax` and its descendents.
+  /// The function called after visiting ``CatchClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CatchClauseSyntax) {
   }
   
-  /// Visiting `CatchItemListSyntax` specifically.
+  /// Visiting ``CatchItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CatchItemListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CatchItemListSyntax` and its descendents.
+  /// The function called after visiting ``CatchItemListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CatchItemListSyntax) {
   }
   
-  /// Visiting `CatchItemSyntax` specifically.
+  /// Visiting ``CatchItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CatchItemSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CatchItemSyntax` and its descendents.
+  /// The function called after visiting ``CatchItemSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CatchItemSyntax) {
   }
   
-  /// Visiting `ClassDeclSyntax` specifically.
+  /// Visiting ``ClassDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClassDeclSyntax` and its descendents.
+  /// The function called after visiting ``ClassDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClassDeclSyntax) {
   }
   
-  /// Visiting `ClassRestrictionTypeSyntax` specifically.
+  /// Visiting ``ClassRestrictionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClassRestrictionTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClassRestrictionTypeSyntax` and its descendents.
+  /// The function called after visiting ``ClassRestrictionTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClassRestrictionTypeSyntax) {
   }
   
-  /// Visiting `ClosureCaptureItemListSyntax` specifically.
+  /// Visiting ``ClosureCaptureItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureCaptureItemListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureCaptureItemListSyntax` and its descendents.
+  /// The function called after visiting ``ClosureCaptureItemListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureCaptureItemListSyntax) {
   }
   
-  /// Visiting `ClosureCaptureItemSpecifierSyntax` specifically.
+  /// Visiting ``ClosureCaptureItemSpecifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureCaptureItemSpecifierSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureCaptureItemSpecifierSyntax` and its descendents.
+  /// The function called after visiting ``ClosureCaptureItemSpecifierSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureCaptureItemSpecifierSyntax) {
   }
   
-  /// Visiting `ClosureCaptureItemSyntax` specifically.
+  /// Visiting ``ClosureCaptureItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureCaptureItemSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureCaptureItemSyntax` and its descendents.
+  /// The function called after visiting ``ClosureCaptureItemSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureCaptureItemSyntax) {
   }
   
-  /// Visiting `ClosureCaptureSignatureSyntax` specifically.
+  /// Visiting ``ClosureCaptureSignatureSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureCaptureSignatureSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureCaptureSignatureSyntax` and its descendents.
+  /// The function called after visiting ``ClosureCaptureSignatureSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureCaptureSignatureSyntax) {
   }
   
-  /// Visiting `ClosureExprSyntax` specifically.
+  /// Visiting ``ClosureExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureExprSyntax` and its descendents.
+  /// The function called after visiting ``ClosureExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureExprSyntax) {
   }
   
-  /// Visiting `ClosureParamListSyntax` specifically.
+  /// Visiting ``ClosureParamListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureParamListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureParamListSyntax` and its descendents.
+  /// The function called after visiting ``ClosureParamListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureParamListSyntax) {
   }
   
-  /// Visiting `ClosureParamSyntax` specifically.
+  /// Visiting ``ClosureParamSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureParamSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureParamSyntax` and its descendents.
+  /// The function called after visiting ``ClosureParamSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureParamSyntax) {
   }
   
-  /// Visiting `ClosureParameterClauseSyntax` specifically.
+  /// Visiting ``ClosureParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureParameterClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureParameterClauseSyntax` and its descendents.
+  /// The function called after visiting ``ClosureParameterClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureParameterClauseSyntax) {
   }
   
-  /// Visiting `ClosureParameterListSyntax` specifically.
+  /// Visiting ``ClosureParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureParameterListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureParameterListSyntax` and its descendents.
+  /// The function called after visiting ``ClosureParameterListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureParameterListSyntax) {
   }
   
-  /// Visiting `ClosureParameterSyntax` specifically.
+  /// Visiting ``ClosureParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureParameterSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureParameterSyntax` and its descendents.
+  /// The function called after visiting ``ClosureParameterSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureParameterSyntax) {
   }
   
-  /// Visiting `ClosureSignatureSyntax` specifically.
+  /// Visiting ``ClosureSignatureSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ClosureSignatureSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ClosureSignatureSyntax` and its descendents.
+  /// The function called after visiting ``ClosureSignatureSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ClosureSignatureSyntax) {
   }
   
-  /// Visiting `CodeBlockItemListSyntax` specifically.
+  /// Visiting ``CodeBlockItemListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CodeBlockItemListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CodeBlockItemListSyntax` and its descendents.
+  /// The function called after visiting ``CodeBlockItemListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CodeBlockItemListSyntax) {
   }
   
-  /// Visiting `CodeBlockItemSyntax` specifically.
+  /// Visiting ``CodeBlockItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CodeBlockItemSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CodeBlockItemSyntax` and its descendents.
+  /// The function called after visiting ``CodeBlockItemSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CodeBlockItemSyntax) {
   }
   
-  /// Visiting `CodeBlockSyntax` specifically.
+  /// Visiting ``CodeBlockSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CodeBlockSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CodeBlockSyntax` and its descendents.
+  /// The function called after visiting ``CodeBlockSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CodeBlockSyntax) {
   }
   
-  /// Visiting `CompositionTypeElementListSyntax` specifically.
+  /// Visiting ``CompositionTypeElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CompositionTypeElementListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CompositionTypeElementListSyntax` and its descendents.
+  /// The function called after visiting ``CompositionTypeElementListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CompositionTypeElementListSyntax) {
   }
   
-  /// Visiting `CompositionTypeElementSyntax` specifically.
+  /// Visiting ``CompositionTypeElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CompositionTypeElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CompositionTypeElementSyntax` and its descendents.
+  /// The function called after visiting ``CompositionTypeElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CompositionTypeElementSyntax) {
   }
   
-  /// Visiting `CompositionTypeSyntax` specifically.
+  /// Visiting ``CompositionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CompositionTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CompositionTypeSyntax` and its descendents.
+  /// The function called after visiting ``CompositionTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CompositionTypeSyntax) {
   }
   
-  /// Visiting `ConditionElementListSyntax` specifically.
+  /// Visiting ``ConditionElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ConditionElementListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ConditionElementListSyntax` and its descendents.
+  /// The function called after visiting ``ConditionElementListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ConditionElementListSyntax) {
   }
   
-  /// Visiting `ConditionElementSyntax` specifically.
+  /// Visiting ``ConditionElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ConditionElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ConditionElementSyntax` and its descendents.
+  /// The function called after visiting ``ConditionElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ConditionElementSyntax) {
   }
   
-  /// Visiting `ConformanceRequirementSyntax` specifically.
+  /// Visiting ``ConformanceRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ConformanceRequirementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ConformanceRequirementSyntax` and its descendents.
+  /// The function called after visiting ``ConformanceRequirementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ConformanceRequirementSyntax) {
   }
   
-  /// Visiting `ConstrainedSugarTypeSyntax` specifically.
+  /// Visiting ``ConstrainedSugarTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ConstrainedSugarTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ConstrainedSugarTypeSyntax` and its descendents.
+  /// The function called after visiting ``ConstrainedSugarTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ConstrainedSugarTypeSyntax) {
   }
   
-  /// Visiting `ContinueStmtSyntax` specifically.
+  /// Visiting ``ContinueStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ContinueStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ContinueStmtSyntax` and its descendents.
+  /// The function called after visiting ``ContinueStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ContinueStmtSyntax) {
   }
   
-  /// Visiting `ConventionAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ConventionAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ConventionAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ConventionAttributeArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``ConventionAttributeArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ConventionAttributeArgumentsSyntax) {
   }
   
-  /// Visiting `ConventionWitnessMethodAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ConventionWitnessMethodAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ConventionWitnessMethodAttributeArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``ConventionWitnessMethodAttributeArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) {
   }
   
-  /// Visiting `CopyExprSyntax` specifically.
+  /// Visiting ``CopyExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: CopyExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `CopyExprSyntax` and its descendents.
+  /// The function called after visiting ``CopyExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: CopyExprSyntax) {
   }
   
-  /// Visiting `DeclModifierDetailSyntax` specifically.
+  /// Visiting ``DeclModifierDetailSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DeclModifierDetailSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DeclModifierDetailSyntax` and its descendents.
+  /// The function called after visiting ``DeclModifierDetailSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DeclModifierDetailSyntax) {
   }
   
-  /// Visiting `DeclModifierSyntax` specifically.
+  /// Visiting ``DeclModifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DeclModifierSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DeclModifierSyntax` and its descendents.
+  /// The function called after visiting ``DeclModifierSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DeclModifierSyntax) {
   }
   
-  /// Visiting `DeclNameArgumentListSyntax` specifically.
+  /// Visiting ``DeclNameArgumentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DeclNameArgumentListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DeclNameArgumentListSyntax` and its descendents.
+  /// The function called after visiting ``DeclNameArgumentListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DeclNameArgumentListSyntax) {
   }
   
-  /// Visiting `DeclNameArgumentSyntax` specifically.
+  /// Visiting ``DeclNameArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DeclNameArgumentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DeclNameArgumentSyntax` and its descendents.
+  /// The function called after visiting ``DeclNameArgumentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DeclNameArgumentSyntax) {
   }
   
-  /// Visiting `DeclNameArgumentsSyntax` specifically.
+  /// Visiting ``DeclNameArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DeclNameArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DeclNameArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``DeclNameArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DeclNameArgumentsSyntax) {
   }
   
-  /// Visiting `DeclNameSyntax` specifically.
+  /// Visiting ``DeclNameSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DeclNameSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DeclNameSyntax` and its descendents.
+  /// The function called after visiting ``DeclNameSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DeclNameSyntax) {
   }
   
-  /// Visiting `DeferStmtSyntax` specifically.
+  /// Visiting ``DeferStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DeferStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DeferStmtSyntax` and its descendents.
+  /// The function called after visiting ``DeferStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DeferStmtSyntax) {
   }
   
-  /// Visiting `DeinitializerDeclSyntax` specifically.
+  /// Visiting ``DeinitializerDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DeinitializerDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DeinitializerDeclSyntax` and its descendents.
+  /// The function called after visiting ``DeinitializerDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DeinitializerDeclSyntax) {
   }
   
-  /// Visiting `DerivativeRegistrationAttributeArgumentsSyntax` specifically.
+  /// Visiting ``DerivativeRegistrationAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DerivativeRegistrationAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DerivativeRegistrationAttributeArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``DerivativeRegistrationAttributeArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DerivativeRegistrationAttributeArgumentsSyntax) {
   }
   
-  /// Visiting `DesignatedTypeElementSyntax` specifically.
+  /// Visiting ``DesignatedTypeElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DesignatedTypeElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DesignatedTypeElementSyntax` and its descendents.
+  /// The function called after visiting ``DesignatedTypeElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DesignatedTypeElementSyntax) {
   }
   
-  /// Visiting `DesignatedTypeListSyntax` specifically.
+  /// Visiting ``DesignatedTypeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DesignatedTypeListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DesignatedTypeListSyntax` and its descendents.
+  /// The function called after visiting ``DesignatedTypeListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DesignatedTypeListSyntax) {
   }
   
-  /// Visiting `DictionaryElementListSyntax` specifically.
+  /// Visiting ``DictionaryElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DictionaryElementListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DictionaryElementListSyntax` and its descendents.
+  /// The function called after visiting ``DictionaryElementListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DictionaryElementListSyntax) {
   }
   
-  /// Visiting `DictionaryElementSyntax` specifically.
+  /// Visiting ``DictionaryElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DictionaryElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DictionaryElementSyntax` and its descendents.
+  /// The function called after visiting ``DictionaryElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DictionaryElementSyntax) {
   }
   
-  /// Visiting `DictionaryExprSyntax` specifically.
+  /// Visiting ``DictionaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DictionaryExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DictionaryExprSyntax` and its descendents.
+  /// The function called after visiting ``DictionaryExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DictionaryExprSyntax) {
   }
   
-  /// Visiting `DictionaryTypeSyntax` specifically.
+  /// Visiting ``DictionaryTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DictionaryTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DictionaryTypeSyntax` and its descendents.
+  /// The function called after visiting ``DictionaryTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DictionaryTypeSyntax) {
   }
   
-  /// Visiting `DifferentiabilityParamListSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DifferentiabilityParamListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DifferentiabilityParamListSyntax` and its descendents.
+  /// The function called after visiting ``DifferentiabilityParamListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DifferentiabilityParamListSyntax) {
   }
   
-  /// Visiting `DifferentiabilityParamSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DifferentiabilityParamSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DifferentiabilityParamSyntax` and its descendents.
+  /// The function called after visiting ``DifferentiabilityParamSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DifferentiabilityParamSyntax) {
   }
   
-  /// Visiting `DifferentiabilityParamsClauseSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamsClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DifferentiabilityParamsClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DifferentiabilityParamsClauseSyntax` and its descendents.
+  /// The function called after visiting ``DifferentiabilityParamsClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DifferentiabilityParamsClauseSyntax) {
   }
   
-  /// Visiting `DifferentiabilityParamsSyntax` specifically.
+  /// Visiting ``DifferentiabilityParamsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DifferentiabilityParamsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DifferentiabilityParamsSyntax` and its descendents.
+  /// The function called after visiting ``DifferentiabilityParamsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DifferentiabilityParamsSyntax) {
   }
   
-  /// Visiting `DifferentiableAttributeArgumentsSyntax` specifically.
+  /// Visiting ``DifferentiableAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DifferentiableAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DifferentiableAttributeArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``DifferentiableAttributeArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DifferentiableAttributeArgumentsSyntax) {
   }
   
-  /// Visiting `DiscardAssignmentExprSyntax` specifically.
+  /// Visiting ``DiscardAssignmentExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DiscardAssignmentExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DiscardAssignmentExprSyntax` and its descendents.
+  /// The function called after visiting ``DiscardAssignmentExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DiscardAssignmentExprSyntax) {
   }
   
-  /// Visiting `DiscardStmtSyntax` specifically.
+  /// Visiting ``DiscardStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DiscardStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DiscardStmtSyntax` and its descendents.
+  /// The function called after visiting ``DiscardStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DiscardStmtSyntax) {
   }
   
-  /// Visiting `DoStmtSyntax` specifically.
+  /// Visiting ``DoStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DoStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DoStmtSyntax` and its descendents.
+  /// The function called after visiting ``DoStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DoStmtSyntax) {
   }
   
-  /// Visiting `DocumentationAttributeArgumentSyntax` specifically.
+  /// Visiting ``DocumentationAttributeArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DocumentationAttributeArgumentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DocumentationAttributeArgumentSyntax` and its descendents.
+  /// The function called after visiting ``DocumentationAttributeArgumentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DocumentationAttributeArgumentSyntax) {
   }
   
-  /// Visiting `DocumentationAttributeArgumentsSyntax` specifically.
+  /// Visiting ``DocumentationAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DocumentationAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DocumentationAttributeArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``DocumentationAttributeArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DocumentationAttributeArgumentsSyntax) {
   }
   
-  /// Visiting `DynamicReplacementArgumentsSyntax` specifically.
+  /// Visiting ``DynamicReplacementArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: DynamicReplacementArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `DynamicReplacementArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``DynamicReplacementArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DynamicReplacementArgumentsSyntax) {
   }
   
-  /// Visiting `EditorPlaceholderDeclSyntax` specifically.
+  /// Visiting ``EditorPlaceholderDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: EditorPlaceholderDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `EditorPlaceholderDeclSyntax` and its descendents.
+  /// The function called after visiting ``EditorPlaceholderDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: EditorPlaceholderDeclSyntax) {
   }
   
-  /// Visiting `EditorPlaceholderExprSyntax` specifically.
+  /// Visiting ``EditorPlaceholderExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: EditorPlaceholderExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `EditorPlaceholderExprSyntax` and its descendents.
+  /// The function called after visiting ``EditorPlaceholderExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: EditorPlaceholderExprSyntax) {
   }
   
-  /// Visiting `EffectsArgumentsSyntax` specifically.
+  /// Visiting ``EffectsArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: EffectsArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `EffectsArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``EffectsArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: EffectsArgumentsSyntax) {
   }
   
-  /// Visiting `EnumCaseDeclSyntax` specifically.
+  /// Visiting ``EnumCaseDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: EnumCaseDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `EnumCaseDeclSyntax` and its descendents.
+  /// The function called after visiting ``EnumCaseDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: EnumCaseDeclSyntax) {
   }
   
-  /// Visiting `EnumCaseElementListSyntax` specifically.
+  /// Visiting ``EnumCaseElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: EnumCaseElementListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `EnumCaseElementListSyntax` and its descendents.
+  /// The function called after visiting ``EnumCaseElementListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: EnumCaseElementListSyntax) {
   }
   
-  /// Visiting `EnumCaseElementSyntax` specifically.
+  /// Visiting ``EnumCaseElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: EnumCaseElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `EnumCaseElementSyntax` and its descendents.
+  /// The function called after visiting ``EnumCaseElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: EnumCaseElementSyntax) {
   }
   
-  /// Visiting `EnumCaseParameterClauseSyntax` specifically.
+  /// Visiting ``EnumCaseParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: EnumCaseParameterClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `EnumCaseParameterClauseSyntax` and its descendents.
+  /// The function called after visiting ``EnumCaseParameterClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: EnumCaseParameterClauseSyntax) {
   }
   
-  /// Visiting `EnumCaseParameterListSyntax` specifically.
+  /// Visiting ``EnumCaseParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: EnumCaseParameterListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `EnumCaseParameterListSyntax` and its descendents.
+  /// The function called after visiting ``EnumCaseParameterListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: EnumCaseParameterListSyntax) {
   }
   
-  /// Visiting `EnumCaseParameterSyntax` specifically.
+  /// Visiting ``EnumCaseParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: EnumCaseParameterSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `EnumCaseParameterSyntax` and its descendents.
+  /// The function called after visiting ``EnumCaseParameterSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: EnumCaseParameterSyntax) {
   }
   
-  /// Visiting `EnumDeclSyntax` specifically.
+  /// Visiting ``EnumDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `EnumDeclSyntax` and its descendents.
+  /// The function called after visiting ``EnumDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: EnumDeclSyntax) {
   }
   
-  /// Visiting `ExposeAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ExposeAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ExposeAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ExposeAttributeArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``ExposeAttributeArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ExposeAttributeArgumentsSyntax) {
   }
   
-  /// Visiting `ExprListSyntax` specifically.
+  /// Visiting ``ExprListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ExprListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ExprListSyntax` and its descendents.
+  /// The function called after visiting ``ExprListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ExprListSyntax) {
   }
   
-  /// Visiting `ExpressionPatternSyntax` specifically.
+  /// Visiting ``ExpressionPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ExpressionPatternSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ExpressionPatternSyntax` and its descendents.
+  /// The function called after visiting ``ExpressionPatternSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ExpressionPatternSyntax) {
   }
   
-  /// Visiting `ExpressionSegmentSyntax` specifically.
+  /// Visiting ``ExpressionSegmentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ExpressionSegmentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ExpressionSegmentSyntax` and its descendents.
+  /// The function called after visiting ``ExpressionSegmentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ExpressionSegmentSyntax) {
   }
   
-  /// Visiting `ExpressionStmtSyntax` specifically.
+  /// Visiting ``ExpressionStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ExpressionStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ExpressionStmtSyntax` and its descendents.
+  /// The function called after visiting ``ExpressionStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ExpressionStmtSyntax) {
   }
   
-  /// Visiting `ExtensionDeclSyntax` specifically.
+  /// Visiting ``ExtensionDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ExtensionDeclSyntax` and its descendents.
+  /// The function called after visiting ``ExtensionDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ExtensionDeclSyntax) {
   }
   
-  /// Visiting `FallthroughStmtSyntax` specifically.
+  /// Visiting ``FallthroughStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: FallthroughStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `FallthroughStmtSyntax` and its descendents.
+  /// The function called after visiting ``FallthroughStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: FallthroughStmtSyntax) {
   }
   
-  /// Visiting `FloatLiteralExprSyntax` specifically.
+  /// Visiting ``FloatLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `FloatLiteralExprSyntax` and its descendents.
+  /// The function called after visiting ``FloatLiteralExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: FloatLiteralExprSyntax) {
   }
   
-  /// Visiting `ForInStmtSyntax` specifically.
+  /// Visiting ``ForInStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ForInStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ForInStmtSyntax` and its descendents.
+  /// The function called after visiting ``ForInStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ForInStmtSyntax) {
   }
   
-  /// Visiting `ForcedValueExprSyntax` specifically.
+  /// Visiting ``ForcedValueExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ForcedValueExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ForcedValueExprSyntax` and its descendents.
+  /// The function called after visiting ``ForcedValueExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ForcedValueExprSyntax) {
   }
   
-  /// Visiting `FunctionCallExprSyntax` specifically.
+  /// Visiting ``FunctionCallExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: FunctionCallExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `FunctionCallExprSyntax` and its descendents.
+  /// The function called after visiting ``FunctionCallExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: FunctionCallExprSyntax) {
   }
   
-  /// Visiting `FunctionDeclSyntax` specifically.
+  /// Visiting ``FunctionDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: FunctionDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `FunctionDeclSyntax` and its descendents.
+  /// The function called after visiting ``FunctionDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: FunctionDeclSyntax) {
   }
   
-  /// Visiting `FunctionEffectSpecifiersSyntax` specifically.
+  /// Visiting ``FunctionEffectSpecifiersSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: FunctionEffectSpecifiersSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `FunctionEffectSpecifiersSyntax` and its descendents.
+  /// The function called after visiting ``FunctionEffectSpecifiersSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: FunctionEffectSpecifiersSyntax) {
   }
   
-  /// Visiting `FunctionParameterListSyntax` specifically.
+  /// Visiting ``FunctionParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: FunctionParameterListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `FunctionParameterListSyntax` and its descendents.
+  /// The function called after visiting ``FunctionParameterListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: FunctionParameterListSyntax) {
   }
   
-  /// Visiting `FunctionParameterSyntax` specifically.
+  /// Visiting ``FunctionParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `FunctionParameterSyntax` and its descendents.
+  /// The function called after visiting ``FunctionParameterSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: FunctionParameterSyntax) {
   }
   
-  /// Visiting `FunctionSignatureSyntax` specifically.
+  /// Visiting ``FunctionSignatureSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: FunctionSignatureSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `FunctionSignatureSyntax` and its descendents.
+  /// The function called after visiting ``FunctionSignatureSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: FunctionSignatureSyntax) {
   }
   
-  /// Visiting `FunctionTypeSyntax` specifically.
+  /// Visiting ``FunctionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: FunctionTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `FunctionTypeSyntax` and its descendents.
+  /// The function called after visiting ``FunctionTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: FunctionTypeSyntax) {
   }
   
-  /// Visiting `GenericArgumentClauseSyntax` specifically.
+  /// Visiting ``GenericArgumentClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: GenericArgumentClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `GenericArgumentClauseSyntax` and its descendents.
+  /// The function called after visiting ``GenericArgumentClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: GenericArgumentClauseSyntax) {
   }
   
-  /// Visiting `GenericArgumentListSyntax` specifically.
+  /// Visiting ``GenericArgumentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: GenericArgumentListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `GenericArgumentListSyntax` and its descendents.
+  /// The function called after visiting ``GenericArgumentListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: GenericArgumentListSyntax) {
   }
   
-  /// Visiting `GenericArgumentSyntax` specifically.
+  /// Visiting ``GenericArgumentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: GenericArgumentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `GenericArgumentSyntax` and its descendents.
+  /// The function called after visiting ``GenericArgumentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: GenericArgumentSyntax) {
   }
   
-  /// Visiting `GenericParameterClauseSyntax` specifically.
+  /// Visiting ``GenericParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: GenericParameterClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `GenericParameterClauseSyntax` and its descendents.
+  /// The function called after visiting ``GenericParameterClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: GenericParameterClauseSyntax) {
   }
   
-  /// Visiting `GenericParameterListSyntax` specifically.
+  /// Visiting ``GenericParameterListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: GenericParameterListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `GenericParameterListSyntax` and its descendents.
+  /// The function called after visiting ``GenericParameterListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: GenericParameterListSyntax) {
   }
   
-  /// Visiting `GenericParameterSyntax` specifically.
+  /// Visiting ``GenericParameterSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: GenericParameterSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `GenericParameterSyntax` and its descendents.
+  /// The function called after visiting ``GenericParameterSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: GenericParameterSyntax) {
   }
   
-  /// Visiting `GenericRequirementListSyntax` specifically.
+  /// Visiting ``GenericRequirementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: GenericRequirementListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `GenericRequirementListSyntax` and its descendents.
+  /// The function called after visiting ``GenericRequirementListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: GenericRequirementListSyntax) {
   }
   
-  /// Visiting `GenericRequirementSyntax` specifically.
+  /// Visiting ``GenericRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: GenericRequirementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `GenericRequirementSyntax` and its descendents.
+  /// The function called after visiting ``GenericRequirementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: GenericRequirementSyntax) {
   }
   
-  /// Visiting `GenericWhereClauseSyntax` specifically.
+  /// Visiting ``GenericWhereClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: GenericWhereClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `GenericWhereClauseSyntax` and its descendents.
+  /// The function called after visiting ``GenericWhereClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: GenericWhereClauseSyntax) {
   }
   
-  /// Visiting `GuardStmtSyntax` specifically.
+  /// Visiting ``GuardStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: GuardStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `GuardStmtSyntax` and its descendents.
+  /// The function called after visiting ``GuardStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: GuardStmtSyntax) {
   }
   
-  /// Visiting `IdentifierExprSyntax` specifically.
+  /// Visiting ``IdentifierExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: IdentifierExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `IdentifierExprSyntax` and its descendents.
+  /// The function called after visiting ``IdentifierExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: IdentifierExprSyntax) {
   }
   
-  /// Visiting `IdentifierPatternSyntax` specifically.
+  /// Visiting ``IdentifierPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: IdentifierPatternSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `IdentifierPatternSyntax` and its descendents.
+  /// The function called after visiting ``IdentifierPatternSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: IdentifierPatternSyntax) {
   }
   
-  /// Visiting `IfConfigClauseListSyntax` specifically.
+  /// Visiting ``IfConfigClauseListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: IfConfigClauseListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `IfConfigClauseListSyntax` and its descendents.
+  /// The function called after visiting ``IfConfigClauseListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: IfConfigClauseListSyntax) {
   }
   
-  /// Visiting `IfConfigClauseSyntax` specifically.
+  /// Visiting ``IfConfigClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: IfConfigClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `IfConfigClauseSyntax` and its descendents.
+  /// The function called after visiting ``IfConfigClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: IfConfigClauseSyntax) {
   }
   
-  /// Visiting `IfConfigDeclSyntax` specifically.
+  /// Visiting ``IfConfigDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: IfConfigDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `IfConfigDeclSyntax` and its descendents.
+  /// The function called after visiting ``IfConfigDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: IfConfigDeclSyntax) {
   }
   
-  /// Visiting `IfExprSyntax` specifically.
+  /// Visiting ``IfExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: IfExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `IfExprSyntax` and its descendents.
+  /// The function called after visiting ``IfExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: IfExprSyntax) {
   }
   
-  /// Visiting `ImplementsAttributeArgumentsSyntax` specifically.
+  /// Visiting ``ImplementsAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ImplementsAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ImplementsAttributeArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``ImplementsAttributeArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ImplementsAttributeArgumentsSyntax) {
   }
   
-  /// Visiting `ImplicitlyUnwrappedOptionalTypeSyntax` specifically.
+  /// Visiting ``ImplicitlyUnwrappedOptionalTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ImplicitlyUnwrappedOptionalTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ImplicitlyUnwrappedOptionalTypeSyntax` and its descendents.
+  /// The function called after visiting ``ImplicitlyUnwrappedOptionalTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ImplicitlyUnwrappedOptionalTypeSyntax) {
   }
   
-  /// Visiting `ImportDeclSyntax` specifically.
+  /// Visiting ``ImportDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ImportDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ImportDeclSyntax` and its descendents.
+  /// The function called after visiting ``ImportDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ImportDeclSyntax) {
   }
   
-  /// Visiting `ImportPathComponentSyntax` specifically.
+  /// Visiting ``ImportPathComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ImportPathComponentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ImportPathComponentSyntax` and its descendents.
+  /// The function called after visiting ``ImportPathComponentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ImportPathComponentSyntax) {
   }
   
-  /// Visiting `ImportPathSyntax` specifically.
+  /// Visiting ``ImportPathSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ImportPathSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ImportPathSyntax` and its descendents.
+  /// The function called after visiting ``ImportPathSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ImportPathSyntax) {
   }
   
-  /// Visiting `InOutExprSyntax` specifically.
+  /// Visiting ``InOutExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: InOutExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `InOutExprSyntax` and its descendents.
+  /// The function called after visiting ``InOutExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: InOutExprSyntax) {
   }
   
-  /// Visiting `InfixOperatorExprSyntax` specifically.
+  /// Visiting ``InfixOperatorExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `InfixOperatorExprSyntax` and its descendents.
+  /// The function called after visiting ``InfixOperatorExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: InfixOperatorExprSyntax) {
   }
   
-  /// Visiting `InheritedTypeListSyntax` specifically.
+  /// Visiting ``InheritedTypeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: InheritedTypeListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `InheritedTypeListSyntax` and its descendents.
+  /// The function called after visiting ``InheritedTypeListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: InheritedTypeListSyntax) {
   }
   
-  /// Visiting `InheritedTypeSyntax` specifically.
+  /// Visiting ``InheritedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: InheritedTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `InheritedTypeSyntax` and its descendents.
+  /// The function called after visiting ``InheritedTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: InheritedTypeSyntax) {
   }
   
-  /// Visiting `InitializerClauseSyntax` specifically.
+  /// Visiting ``InitializerClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: InitializerClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `InitializerClauseSyntax` and its descendents.
+  /// The function called after visiting ``InitializerClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: InitializerClauseSyntax) {
   }
   
-  /// Visiting `InitializerDeclSyntax` specifically.
+  /// Visiting ``InitializerDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: InitializerDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `InitializerDeclSyntax` and its descendents.
+  /// The function called after visiting ``InitializerDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: InitializerDeclSyntax) {
   }
   
-  /// Visiting `IntegerLiteralExprSyntax` specifically.
+  /// Visiting ``IntegerLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `IntegerLiteralExprSyntax` and its descendents.
+  /// The function called after visiting ``IntegerLiteralExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: IntegerLiteralExprSyntax) {
   }
   
-  /// Visiting `IsExprSyntax` specifically.
+  /// Visiting ``IsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: IsExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `IsExprSyntax` and its descendents.
+  /// The function called after visiting ``IsExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: IsExprSyntax) {
   }
   
-  /// Visiting `IsTypePatternSyntax` specifically.
+  /// Visiting ``IsTypePatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: IsTypePatternSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `IsTypePatternSyntax` and its descendents.
+  /// The function called after visiting ``IsTypePatternSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: IsTypePatternSyntax) {
   }
   
-  /// Visiting `KeyPathComponentListSyntax` specifically.
+  /// Visiting ``KeyPathComponentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: KeyPathComponentListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `KeyPathComponentListSyntax` and its descendents.
+  /// The function called after visiting ``KeyPathComponentListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: KeyPathComponentListSyntax) {
   }
   
-  /// Visiting `KeyPathComponentSyntax` specifically.
+  /// Visiting ``KeyPathComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: KeyPathComponentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `KeyPathComponentSyntax` and its descendents.
+  /// The function called after visiting ``KeyPathComponentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: KeyPathComponentSyntax) {
   }
   
-  /// Visiting `KeyPathExprSyntax` specifically.
+  /// Visiting ``KeyPathExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: KeyPathExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `KeyPathExprSyntax` and its descendents.
+  /// The function called after visiting ``KeyPathExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: KeyPathExprSyntax) {
   }
   
-  /// Visiting `KeyPathOptionalComponentSyntax` specifically.
+  /// Visiting ``KeyPathOptionalComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: KeyPathOptionalComponentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `KeyPathOptionalComponentSyntax` and its descendents.
+  /// The function called after visiting ``KeyPathOptionalComponentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: KeyPathOptionalComponentSyntax) {
   }
   
-  /// Visiting `KeyPathPropertyComponentSyntax` specifically.
+  /// Visiting ``KeyPathPropertyComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: KeyPathPropertyComponentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `KeyPathPropertyComponentSyntax` and its descendents.
+  /// The function called after visiting ``KeyPathPropertyComponentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: KeyPathPropertyComponentSyntax) {
   }
   
-  /// Visiting `KeyPathSubscriptComponentSyntax` specifically.
+  /// Visiting ``KeyPathSubscriptComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: KeyPathSubscriptComponentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `KeyPathSubscriptComponentSyntax` and its descendents.
+  /// The function called after visiting ``KeyPathSubscriptComponentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: KeyPathSubscriptComponentSyntax) {
   }
   
-  /// Visiting `LabeledSpecializeEntrySyntax` specifically.
+  /// Visiting ``LabeledSpecializeEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: LabeledSpecializeEntrySyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `LabeledSpecializeEntrySyntax` and its descendents.
+  /// The function called after visiting ``LabeledSpecializeEntrySyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: LabeledSpecializeEntrySyntax) {
   }
   
-  /// Visiting `LabeledStmtSyntax` specifically.
+  /// Visiting ``LabeledStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: LabeledStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `LabeledStmtSyntax` and its descendents.
+  /// The function called after visiting ``LabeledStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: LabeledStmtSyntax) {
   }
   
-  /// Visiting `LayoutRequirementSyntax` specifically.
+  /// Visiting ``LayoutRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: LayoutRequirementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `LayoutRequirementSyntax` and its descendents.
+  /// The function called after visiting ``LayoutRequirementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: LayoutRequirementSyntax) {
   }
   
-  /// Visiting `MacroDeclSyntax` specifically.
+  /// Visiting ``MacroDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MacroDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MacroDeclSyntax` and its descendents.
+  /// The function called after visiting ``MacroDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MacroDeclSyntax) {
   }
   
-  /// Visiting `MacroExpansionDeclSyntax` specifically.
+  /// Visiting ``MacroExpansionDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MacroExpansionDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MacroExpansionDeclSyntax` and its descendents.
+  /// The function called after visiting ``MacroExpansionDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MacroExpansionDeclSyntax) {
   }
   
-  /// Visiting `MacroExpansionExprSyntax` specifically.
+  /// Visiting ``MacroExpansionExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MacroExpansionExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MacroExpansionExprSyntax` and its descendents.
+  /// The function called after visiting ``MacroExpansionExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MacroExpansionExprSyntax) {
   }
   
-  /// Visiting `MatchingPatternConditionSyntax` specifically.
+  /// Visiting ``MatchingPatternConditionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MatchingPatternConditionSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MatchingPatternConditionSyntax` and its descendents.
+  /// The function called after visiting ``MatchingPatternConditionSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MatchingPatternConditionSyntax) {
   }
   
-  /// Visiting `MemberAccessExprSyntax` specifically.
+  /// Visiting ``MemberAccessExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MemberAccessExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MemberAccessExprSyntax` and its descendents.
+  /// The function called after visiting ``MemberAccessExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MemberAccessExprSyntax) {
   }
   
-  /// Visiting `MemberDeclBlockSyntax` specifically.
+  /// Visiting ``MemberDeclBlockSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MemberDeclBlockSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MemberDeclBlockSyntax` and its descendents.
+  /// The function called after visiting ``MemberDeclBlockSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MemberDeclBlockSyntax) {
   }
   
-  /// Visiting `MemberDeclListItemSyntax` specifically.
+  /// Visiting ``MemberDeclListItemSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MemberDeclListItemSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MemberDeclListItemSyntax` and its descendents.
+  /// The function called after visiting ``MemberDeclListItemSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MemberDeclListItemSyntax) {
   }
   
-  /// Visiting `MemberDeclListSyntax` specifically.
+  /// Visiting ``MemberDeclListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MemberDeclListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MemberDeclListSyntax` and its descendents.
+  /// The function called after visiting ``MemberDeclListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MemberDeclListSyntax) {
   }
   
-  /// Visiting `MemberTypeIdentifierSyntax` specifically.
+  /// Visiting ``MemberTypeIdentifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MemberTypeIdentifierSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MemberTypeIdentifierSyntax` and its descendents.
+  /// The function called after visiting ``MemberTypeIdentifierSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MemberTypeIdentifierSyntax) {
   }
   
-  /// Visiting `MetatypeTypeSyntax` specifically.
+  /// Visiting ``MetatypeTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MetatypeTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MetatypeTypeSyntax` and its descendents.
+  /// The function called after visiting ``MetatypeTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MetatypeTypeSyntax) {
   }
   
-  /// Visiting `MissingDeclSyntax` specifically.
+  /// Visiting ``MissingDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MissingDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MissingDeclSyntax` and its descendents.
+  /// The function called after visiting ``MissingDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MissingDeclSyntax) {
   }
   
-  /// Visiting `MissingExprSyntax` specifically.
+  /// Visiting ``MissingExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MissingExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MissingExprSyntax` and its descendents.
+  /// The function called after visiting ``MissingExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MissingExprSyntax) {
   }
   
-  /// Visiting `MissingPatternSyntax` specifically.
+  /// Visiting ``MissingPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MissingPatternSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MissingPatternSyntax` and its descendents.
+  /// The function called after visiting ``MissingPatternSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MissingPatternSyntax) {
   }
   
-  /// Visiting `MissingStmtSyntax` specifically.
+  /// Visiting ``MissingStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MissingStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MissingStmtSyntax` and its descendents.
+  /// The function called after visiting ``MissingStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MissingStmtSyntax) {
   }
   
-  /// Visiting `MissingSyntax` specifically.
+  /// Visiting ``MissingSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MissingSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MissingSyntax` and its descendents.
+  /// The function called after visiting ``MissingSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MissingSyntax) {
   }
   
-  /// Visiting `MissingTypeSyntax` specifically.
+  /// Visiting ``MissingTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MissingTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MissingTypeSyntax` and its descendents.
+  /// The function called after visiting ``MissingTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MissingTypeSyntax) {
   }
   
-  /// Visiting `ModifierListSyntax` specifically.
+  /// Visiting ``ModifierListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ModifierListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ModifierListSyntax` and its descendents.
+  /// The function called after visiting ``ModifierListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ModifierListSyntax) {
   }
   
-  /// Visiting `MoveExprSyntax` specifically.
+  /// Visiting ``MoveExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MoveExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MoveExprSyntax` and its descendents.
+  /// The function called after visiting ``MoveExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MoveExprSyntax) {
   }
   
-  /// Visiting `MultipleTrailingClosureElementListSyntax` specifically.
+  /// Visiting ``MultipleTrailingClosureElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MultipleTrailingClosureElementListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MultipleTrailingClosureElementListSyntax` and its descendents.
+  /// The function called after visiting ``MultipleTrailingClosureElementListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MultipleTrailingClosureElementListSyntax) {
   }
   
-  /// Visiting `MultipleTrailingClosureElementSyntax` specifically.
+  /// Visiting ``MultipleTrailingClosureElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: MultipleTrailingClosureElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `MultipleTrailingClosureElementSyntax` and its descendents.
+  /// The function called after visiting ``MultipleTrailingClosureElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: MultipleTrailingClosureElementSyntax) {
   }
   
-  /// Visiting `NamedOpaqueReturnTypeSyntax` specifically.
+  /// Visiting ``NamedOpaqueReturnTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: NamedOpaqueReturnTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `NamedOpaqueReturnTypeSyntax` and its descendents.
+  /// The function called after visiting ``NamedOpaqueReturnTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: NamedOpaqueReturnTypeSyntax) {
   }
   
-  /// Visiting `NilLiteralExprSyntax` specifically.
+  /// Visiting ``NilLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: NilLiteralExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `NilLiteralExprSyntax` and its descendents.
+  /// The function called after visiting ``NilLiteralExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: NilLiteralExprSyntax) {
   }
   
-  /// Visiting `ObjCSelectorPieceSyntax` specifically.
+  /// Visiting ``ObjCSelectorPieceSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ObjCSelectorPieceSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ObjCSelectorPieceSyntax` and its descendents.
+  /// The function called after visiting ``ObjCSelectorPieceSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ObjCSelectorPieceSyntax) {
   }
   
-  /// Visiting `ObjCSelectorSyntax` specifically.
+  /// Visiting ``ObjCSelectorSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ObjCSelectorSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ObjCSelectorSyntax` and its descendents.
+  /// The function called after visiting ``ObjCSelectorSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ObjCSelectorSyntax) {
   }
   
-  /// Visiting `OpaqueReturnTypeOfAttributeArgumentsSyntax` specifically.
+  /// Visiting ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `OpaqueReturnTypeOfAttributeArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) {
   }
   
-  /// Visiting `OperatorDeclSyntax` specifically.
+  /// Visiting ``OperatorDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: OperatorDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `OperatorDeclSyntax` and its descendents.
+  /// The function called after visiting ``OperatorDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: OperatorDeclSyntax) {
   }
   
-  /// Visiting `OperatorPrecedenceAndTypesSyntax` specifically.
+  /// Visiting ``OperatorPrecedenceAndTypesSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: OperatorPrecedenceAndTypesSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `OperatorPrecedenceAndTypesSyntax` and its descendents.
+  /// The function called after visiting ``OperatorPrecedenceAndTypesSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: OperatorPrecedenceAndTypesSyntax) {
   }
   
-  /// Visiting `OptionalBindingConditionSyntax` specifically.
+  /// Visiting ``OptionalBindingConditionSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: OptionalBindingConditionSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `OptionalBindingConditionSyntax` and its descendents.
+  /// The function called after visiting ``OptionalBindingConditionSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: OptionalBindingConditionSyntax) {
   }
   
-  /// Visiting `OptionalChainingExprSyntax` specifically.
+  /// Visiting ``OptionalChainingExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: OptionalChainingExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `OptionalChainingExprSyntax` and its descendents.
+  /// The function called after visiting ``OptionalChainingExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: OptionalChainingExprSyntax) {
   }
   
-  /// Visiting `OptionalTypeSyntax` specifically.
+  /// Visiting ``OptionalTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: OptionalTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `OptionalTypeSyntax` and its descendents.
+  /// The function called after visiting ``OptionalTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: OptionalTypeSyntax) {
   }
   
-  /// Visiting `OriginallyDefinedInArgumentsSyntax` specifically.
+  /// Visiting ``OriginallyDefinedInArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: OriginallyDefinedInArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `OriginallyDefinedInArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``OriginallyDefinedInArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: OriginallyDefinedInArgumentsSyntax) {
   }
   
-  /// Visiting `PackElementExprSyntax` specifically.
+  /// Visiting ``PackElementExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PackElementExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PackElementExprSyntax` and its descendents.
+  /// The function called after visiting ``PackElementExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PackElementExprSyntax) {
   }
   
-  /// Visiting `PackExpansionExprSyntax` specifically.
+  /// Visiting ``PackExpansionExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PackExpansionExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PackExpansionExprSyntax` and its descendents.
+  /// The function called after visiting ``PackExpansionExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PackExpansionExprSyntax) {
   }
   
-  /// Visiting `PackExpansionTypeSyntax` specifically.
+  /// Visiting ``PackExpansionTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PackExpansionTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PackExpansionTypeSyntax` and its descendents.
+  /// The function called after visiting ``PackExpansionTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PackExpansionTypeSyntax) {
   }
   
-  /// Visiting `PackReferenceTypeSyntax` specifically.
+  /// Visiting ``PackReferenceTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PackReferenceTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PackReferenceTypeSyntax` and its descendents.
+  /// The function called after visiting ``PackReferenceTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PackReferenceTypeSyntax) {
   }
   
-  /// Visiting `ParameterClauseSyntax` specifically.
+  /// Visiting ``ParameterClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ParameterClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ParameterClauseSyntax` and its descendents.
+  /// The function called after visiting ``ParameterClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ParameterClauseSyntax) {
   }
   
-  /// Visiting `PatternBindingListSyntax` specifically.
+  /// Visiting ``PatternBindingListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PatternBindingListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PatternBindingListSyntax` and its descendents.
+  /// The function called after visiting ``PatternBindingListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PatternBindingListSyntax) {
   }
   
-  /// Visiting `PatternBindingSyntax` specifically.
+  /// Visiting ``PatternBindingSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PatternBindingSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PatternBindingSyntax` and its descendents.
+  /// The function called after visiting ``PatternBindingSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PatternBindingSyntax) {
   }
   
-  /// Visiting `PostfixIfConfigExprSyntax` specifically.
+  /// Visiting ``PostfixIfConfigExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PostfixIfConfigExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PostfixIfConfigExprSyntax` and its descendents.
+  /// The function called after visiting ``PostfixIfConfigExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PostfixIfConfigExprSyntax) {
   }
   
-  /// Visiting `PostfixUnaryExprSyntax` specifically.
+  /// Visiting ``PostfixUnaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PostfixUnaryExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PostfixUnaryExprSyntax` and its descendents.
+  /// The function called after visiting ``PostfixUnaryExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PostfixUnaryExprSyntax) {
   }
   
-  /// Visiting `PoundSourceLocationArgsSyntax` specifically.
+  /// Visiting ``PoundSourceLocationArgsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PoundSourceLocationArgsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PoundSourceLocationArgsSyntax` and its descendents.
+  /// The function called after visiting ``PoundSourceLocationArgsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PoundSourceLocationArgsSyntax) {
   }
   
-  /// Visiting `PoundSourceLocationSyntax` specifically.
+  /// Visiting ``PoundSourceLocationSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PoundSourceLocationSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PoundSourceLocationSyntax` and its descendents.
+  /// The function called after visiting ``PoundSourceLocationSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PoundSourceLocationSyntax) {
   }
   
-  /// Visiting `PrecedenceGroupAssignmentSyntax` specifically.
+  /// Visiting ``PrecedenceGroupAssignmentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrecedenceGroupAssignmentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrecedenceGroupAssignmentSyntax` and its descendents.
+  /// The function called after visiting ``PrecedenceGroupAssignmentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrecedenceGroupAssignmentSyntax) {
   }
   
-  /// Visiting `PrecedenceGroupAssociativitySyntax` specifically.
+  /// Visiting ``PrecedenceGroupAssociativitySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrecedenceGroupAssociativitySyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrecedenceGroupAssociativitySyntax` and its descendents.
+  /// The function called after visiting ``PrecedenceGroupAssociativitySyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrecedenceGroupAssociativitySyntax) {
   }
   
-  /// Visiting `PrecedenceGroupAttributeListSyntax` specifically.
+  /// Visiting ``PrecedenceGroupAttributeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrecedenceGroupAttributeListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrecedenceGroupAttributeListSyntax` and its descendents.
+  /// The function called after visiting ``PrecedenceGroupAttributeListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrecedenceGroupAttributeListSyntax) {
   }
   
-  /// Visiting `PrecedenceGroupDeclSyntax` specifically.
+  /// Visiting ``PrecedenceGroupDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrecedenceGroupDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrecedenceGroupDeclSyntax` and its descendents.
+  /// The function called after visiting ``PrecedenceGroupDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrecedenceGroupDeclSyntax) {
   }
   
-  /// Visiting `PrecedenceGroupNameElementSyntax` specifically.
+  /// Visiting ``PrecedenceGroupNameElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrecedenceGroupNameElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrecedenceGroupNameElementSyntax` and its descendents.
+  /// The function called after visiting ``PrecedenceGroupNameElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrecedenceGroupNameElementSyntax) {
   }
   
-  /// Visiting `PrecedenceGroupNameListSyntax` specifically.
+  /// Visiting ``PrecedenceGroupNameListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrecedenceGroupNameListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrecedenceGroupNameListSyntax` and its descendents.
+  /// The function called after visiting ``PrecedenceGroupNameListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrecedenceGroupNameListSyntax) {
   }
   
-  /// Visiting `PrecedenceGroupRelationSyntax` specifically.
+  /// Visiting ``PrecedenceGroupRelationSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrecedenceGroupRelationSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrecedenceGroupRelationSyntax` and its descendents.
+  /// The function called after visiting ``PrecedenceGroupRelationSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrecedenceGroupRelationSyntax) {
   }
   
-  /// Visiting `PrefixOperatorExprSyntax` specifically.
+  /// Visiting ``PrefixOperatorExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrefixOperatorExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrefixOperatorExprSyntax` and its descendents.
+  /// The function called after visiting ``PrefixOperatorExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrefixOperatorExprSyntax) {
   }
   
-  /// Visiting `PrimaryAssociatedTypeClauseSyntax` specifically.
+  /// Visiting ``PrimaryAssociatedTypeClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrimaryAssociatedTypeClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrimaryAssociatedTypeClauseSyntax` and its descendents.
+  /// The function called after visiting ``PrimaryAssociatedTypeClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrimaryAssociatedTypeClauseSyntax) {
   }
   
-  /// Visiting `PrimaryAssociatedTypeListSyntax` specifically.
+  /// Visiting ``PrimaryAssociatedTypeListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrimaryAssociatedTypeListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrimaryAssociatedTypeListSyntax` and its descendents.
+  /// The function called after visiting ``PrimaryAssociatedTypeListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrimaryAssociatedTypeListSyntax) {
   }
   
-  /// Visiting `PrimaryAssociatedTypeSyntax` specifically.
+  /// Visiting ``PrimaryAssociatedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: PrimaryAssociatedTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `PrimaryAssociatedTypeSyntax` and its descendents.
+  /// The function called after visiting ``PrimaryAssociatedTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PrimaryAssociatedTypeSyntax) {
   }
   
-  /// Visiting `ProtocolDeclSyntax` specifically.
+  /// Visiting ``ProtocolDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ProtocolDeclSyntax` and its descendents.
+  /// The function called after visiting ``ProtocolDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ProtocolDeclSyntax) {
   }
   
-  /// Visiting `QualifiedDeclNameSyntax` specifically.
+  /// Visiting ``QualifiedDeclNameSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: QualifiedDeclNameSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `QualifiedDeclNameSyntax` and its descendents.
+  /// The function called after visiting ``QualifiedDeclNameSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: QualifiedDeclNameSyntax) {
   }
   
-  /// Visiting `RegexLiteralExprSyntax` specifically.
+  /// Visiting ``RegexLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: RegexLiteralExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `RegexLiteralExprSyntax` and its descendents.
+  /// The function called after visiting ``RegexLiteralExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: RegexLiteralExprSyntax) {
   }
   
-  /// Visiting `RepeatWhileStmtSyntax` specifically.
+  /// Visiting ``RepeatWhileStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: RepeatWhileStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `RepeatWhileStmtSyntax` and its descendents.
+  /// The function called after visiting ``RepeatWhileStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: RepeatWhileStmtSyntax) {
   }
   
-  /// Visiting `ReturnClauseSyntax` specifically.
+  /// Visiting ``ReturnClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ReturnClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ReturnClauseSyntax` and its descendents.
+  /// The function called after visiting ``ReturnClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ReturnClauseSyntax) {
   }
   
-  /// Visiting `ReturnStmtSyntax` specifically.
+  /// Visiting ``ReturnStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ReturnStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ReturnStmtSyntax` and its descendents.
+  /// The function called after visiting ``ReturnStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ReturnStmtSyntax) {
   }
   
-  /// Visiting `SameTypeRequirementSyntax` specifically.
+  /// Visiting ``SameTypeRequirementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SameTypeRequirementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SameTypeRequirementSyntax` and its descendents.
+  /// The function called after visiting ``SameTypeRequirementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SameTypeRequirementSyntax) {
   }
   
-  /// Visiting `SequenceExprSyntax` specifically.
+  /// Visiting ``SequenceExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SequenceExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SequenceExprSyntax` and its descendents.
+  /// The function called after visiting ``SequenceExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SequenceExprSyntax) {
   }
   
-  /// Visiting `SimpleTypeIdentifierSyntax` specifically.
+  /// Visiting ``SimpleTypeIdentifierSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SimpleTypeIdentifierSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SimpleTypeIdentifierSyntax` and its descendents.
+  /// The function called after visiting ``SimpleTypeIdentifierSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SimpleTypeIdentifierSyntax) {
   }
   
-  /// Visiting `SourceFileSyntax` specifically.
+  /// Visiting ``SourceFileSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SourceFileSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SourceFileSyntax` and its descendents.
+  /// The function called after visiting ``SourceFileSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SourceFileSyntax) {
   }
   
-  /// Visiting `SpecializeAttributeSpecListSyntax` specifically.
+  /// Visiting ``SpecializeAttributeSpecListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SpecializeAttributeSpecListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SpecializeAttributeSpecListSyntax` and its descendents.
+  /// The function called after visiting ``SpecializeAttributeSpecListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SpecializeAttributeSpecListSyntax) {
   }
   
-  /// Visiting `SpecializeExprSyntax` specifically.
+  /// Visiting ``SpecializeExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SpecializeExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SpecializeExprSyntax` and its descendents.
+  /// The function called after visiting ``SpecializeExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SpecializeExprSyntax) {
   }
   
-  /// Visiting `StringLiteralExprSyntax` specifically.
+  /// Visiting ``StringLiteralExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: StringLiteralExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `StringLiteralExprSyntax` and its descendents.
+  /// The function called after visiting ``StringLiteralExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: StringLiteralExprSyntax) {
   }
   
-  /// Visiting `StringLiteralSegmentsSyntax` specifically.
+  /// Visiting ``StringLiteralSegmentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: StringLiteralSegmentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `StringLiteralSegmentsSyntax` and its descendents.
+  /// The function called after visiting ``StringLiteralSegmentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: StringLiteralSegmentsSyntax) {
   }
   
-  /// Visiting `StringSegmentSyntax` specifically.
+  /// Visiting ``StringSegmentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: StringSegmentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `StringSegmentSyntax` and its descendents.
+  /// The function called after visiting ``StringSegmentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: StringSegmentSyntax) {
   }
   
-  /// Visiting `StructDeclSyntax` specifically.
+  /// Visiting ``StructDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `StructDeclSyntax` and its descendents.
+  /// The function called after visiting ``StructDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: StructDeclSyntax) {
   }
   
-  /// Visiting `SubscriptDeclSyntax` specifically.
+  /// Visiting ``SubscriptDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SubscriptDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SubscriptDeclSyntax` and its descendents.
+  /// The function called after visiting ``SubscriptDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SubscriptDeclSyntax) {
   }
   
-  /// Visiting `SubscriptExprSyntax` specifically.
+  /// Visiting ``SubscriptExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SubscriptExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SubscriptExprSyntax` and its descendents.
+  /// The function called after visiting ``SubscriptExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SubscriptExprSyntax) {
   }
   
-  /// Visiting `SuperRefExprSyntax` specifically.
+  /// Visiting ``SuperRefExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SuperRefExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SuperRefExprSyntax` and its descendents.
+  /// The function called after visiting ``SuperRefExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SuperRefExprSyntax) {
   }
   
-  /// Visiting `SuppressedTypeSyntax` specifically.
+  /// Visiting ``SuppressedTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SuppressedTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SuppressedTypeSyntax` and its descendents.
+  /// The function called after visiting ``SuppressedTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SuppressedTypeSyntax) {
   }
   
-  /// Visiting `SwitchCaseLabelSyntax` specifically.
+  /// Visiting ``SwitchCaseLabelSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SwitchCaseLabelSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SwitchCaseLabelSyntax` and its descendents.
+  /// The function called after visiting ``SwitchCaseLabelSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SwitchCaseLabelSyntax) {
   }
   
-  /// Visiting `SwitchCaseListSyntax` specifically.
+  /// Visiting ``SwitchCaseListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SwitchCaseListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SwitchCaseListSyntax` and its descendents.
+  /// The function called after visiting ``SwitchCaseListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SwitchCaseListSyntax) {
   }
   
-  /// Visiting `SwitchCaseSyntax` specifically.
+  /// Visiting ``SwitchCaseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SwitchCaseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SwitchCaseSyntax` and its descendents.
+  /// The function called after visiting ``SwitchCaseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SwitchCaseSyntax) {
   }
   
-  /// Visiting `SwitchDefaultLabelSyntax` specifically.
+  /// Visiting ``SwitchDefaultLabelSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SwitchDefaultLabelSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SwitchDefaultLabelSyntax` and its descendents.
+  /// The function called after visiting ``SwitchDefaultLabelSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SwitchDefaultLabelSyntax) {
   }
   
-  /// Visiting `SwitchExprSyntax` specifically.
+  /// Visiting ``SwitchExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: SwitchExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `SwitchExprSyntax` and its descendents.
+  /// The function called after visiting ``SwitchExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SwitchExprSyntax) {
   }
   
-  /// Visiting `TargetFunctionEntrySyntax` specifically.
+  /// Visiting ``TargetFunctionEntrySyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TargetFunctionEntrySyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TargetFunctionEntrySyntax` and its descendents.
+  /// The function called after visiting ``TargetFunctionEntrySyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TargetFunctionEntrySyntax) {
   }
   
-  /// Visiting `TernaryExprSyntax` specifically.
+  /// Visiting ``TernaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TernaryExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TernaryExprSyntax` and its descendents.
+  /// The function called after visiting ``TernaryExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TernaryExprSyntax) {
   }
   
-  /// Visiting `ThrowStmtSyntax` specifically.
+  /// Visiting ``ThrowStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ThrowStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ThrowStmtSyntax` and its descendents.
+  /// The function called after visiting ``ThrowStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ThrowStmtSyntax) {
   }
   
-  /// Visiting `TryExprSyntax` specifically.
+  /// Visiting ``TryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TryExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TryExprSyntax` and its descendents.
+  /// The function called after visiting ``TryExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TryExprSyntax) {
   }
   
-  /// Visiting `TupleExprElementListSyntax` specifically.
+  /// Visiting ``TupleExprElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TupleExprElementListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TupleExprElementListSyntax` and its descendents.
+  /// The function called after visiting ``TupleExprElementListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TupleExprElementListSyntax) {
   }
   
-  /// Visiting `TupleExprElementSyntax` specifically.
+  /// Visiting ``TupleExprElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TupleExprElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TupleExprElementSyntax` and its descendents.
+  /// The function called after visiting ``TupleExprElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TupleExprElementSyntax) {
   }
   
-  /// Visiting `TupleExprSyntax` specifically.
+  /// Visiting ``TupleExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TupleExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TupleExprSyntax` and its descendents.
+  /// The function called after visiting ``TupleExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TupleExprSyntax) {
   }
   
-  /// Visiting `TuplePatternElementListSyntax` specifically.
+  /// Visiting ``TuplePatternElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TuplePatternElementListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TuplePatternElementListSyntax` and its descendents.
+  /// The function called after visiting ``TuplePatternElementListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TuplePatternElementListSyntax) {
   }
   
-  /// Visiting `TuplePatternElementSyntax` specifically.
+  /// Visiting ``TuplePatternElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TuplePatternElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TuplePatternElementSyntax` and its descendents.
+  /// The function called after visiting ``TuplePatternElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TuplePatternElementSyntax) {
   }
   
-  /// Visiting `TuplePatternSyntax` specifically.
+  /// Visiting ``TuplePatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TuplePatternSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TuplePatternSyntax` and its descendents.
+  /// The function called after visiting ``TuplePatternSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TuplePatternSyntax) {
   }
   
-  /// Visiting `TupleTypeElementListSyntax` specifically.
+  /// Visiting ``TupleTypeElementListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TupleTypeElementListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TupleTypeElementListSyntax` and its descendents.
+  /// The function called after visiting ``TupleTypeElementListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TupleTypeElementListSyntax) {
   }
   
-  /// Visiting `TupleTypeElementSyntax` specifically.
+  /// Visiting ``TupleTypeElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TupleTypeElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TupleTypeElementSyntax` and its descendents.
+  /// The function called after visiting ``TupleTypeElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TupleTypeElementSyntax) {
   }
   
-  /// Visiting `TupleTypeSyntax` specifically.
+  /// Visiting ``TupleTypeSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TupleTypeSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TupleTypeSyntax` and its descendents.
+  /// The function called after visiting ``TupleTypeSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TupleTypeSyntax) {
   }
   
-  /// Visiting `TypeAnnotationSyntax` specifically.
+  /// Visiting ``TypeAnnotationSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TypeAnnotationSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TypeAnnotationSyntax` and its descendents.
+  /// The function called after visiting ``TypeAnnotationSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TypeAnnotationSyntax) {
   }
   
-  /// Visiting `TypeEffectSpecifiersSyntax` specifically.
+  /// Visiting ``TypeEffectSpecifiersSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TypeEffectSpecifiersSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TypeEffectSpecifiersSyntax` and its descendents.
+  /// The function called after visiting ``TypeEffectSpecifiersSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TypeEffectSpecifiersSyntax) {
   }
   
-  /// Visiting `TypeExprSyntax` specifically.
+  /// Visiting ``TypeExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TypeExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TypeExprSyntax` and its descendents.
+  /// The function called after visiting ``TypeExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TypeExprSyntax) {
   }
   
-  /// Visiting `TypeInheritanceClauseSyntax` specifically.
+  /// Visiting ``TypeInheritanceClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TypeInheritanceClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TypeInheritanceClauseSyntax` and its descendents.
+  /// The function called after visiting ``TypeInheritanceClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TypeInheritanceClauseSyntax) {
   }
   
-  /// Visiting `TypeInitializerClauseSyntax` specifically.
+  /// Visiting ``TypeInitializerClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TypeInitializerClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TypeInitializerClauseSyntax` and its descendents.
+  /// The function called after visiting ``TypeInitializerClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TypeInitializerClauseSyntax) {
   }
   
-  /// Visiting `TypealiasDeclSyntax` specifically.
+  /// Visiting ``TypealiasDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: TypealiasDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `TypealiasDeclSyntax` and its descendents.
+  /// The function called after visiting ``TypealiasDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TypealiasDeclSyntax) {
   }
   
-  /// Visiting `UnavailableFromAsyncArgumentsSyntax` specifically.
+  /// Visiting ``UnavailableFromAsyncArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: UnavailableFromAsyncArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `UnavailableFromAsyncArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``UnavailableFromAsyncArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: UnavailableFromAsyncArgumentsSyntax) {
   }
   
-  /// Visiting `UnderscorePrivateAttributeArgumentsSyntax` specifically.
+  /// Visiting ``UnderscorePrivateAttributeArgumentsSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: UnderscorePrivateAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `UnderscorePrivateAttributeArgumentsSyntax` and its descendents.
+  /// The function called after visiting ``UnderscorePrivateAttributeArgumentsSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: UnderscorePrivateAttributeArgumentsSyntax) {
   }
   
-  /// Visiting `UnexpectedNodesSyntax` specifically.
+  /// Visiting ``UnexpectedNodesSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: UnexpectedNodesSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `UnexpectedNodesSyntax` and its descendents.
+  /// The function called after visiting ``UnexpectedNodesSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: UnexpectedNodesSyntax) {
   }
   
-  /// Visiting `UnresolvedAsExprSyntax` specifically.
+  /// Visiting ``UnresolvedAsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: UnresolvedAsExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `UnresolvedAsExprSyntax` and its descendents.
+  /// The function called after visiting ``UnresolvedAsExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: UnresolvedAsExprSyntax) {
   }
   
-  /// Visiting `UnresolvedIsExprSyntax` specifically.
+  /// Visiting ``UnresolvedIsExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: UnresolvedIsExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `UnresolvedIsExprSyntax` and its descendents.
+  /// The function called after visiting ``UnresolvedIsExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: UnresolvedIsExprSyntax) {
   }
   
-  /// Visiting `UnresolvedPatternExprSyntax` specifically.
+  /// Visiting ``UnresolvedPatternExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: UnresolvedPatternExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `UnresolvedPatternExprSyntax` and its descendents.
+  /// The function called after visiting ``UnresolvedPatternExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: UnresolvedPatternExprSyntax) {
   }
   
-  /// Visiting `UnresolvedTernaryExprSyntax` specifically.
+  /// Visiting ``UnresolvedTernaryExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: UnresolvedTernaryExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `UnresolvedTernaryExprSyntax` and its descendents.
+  /// The function called after visiting ``UnresolvedTernaryExprSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: UnresolvedTernaryExprSyntax) {
   }
   
-  /// Visiting `ValueBindingPatternSyntax` specifically.
+  /// Visiting ``ValueBindingPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: ValueBindingPatternSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `ValueBindingPatternSyntax` and its descendents.
+  /// The function called after visiting ``ValueBindingPatternSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ValueBindingPatternSyntax) {
   }
   
-  /// Visiting `VariableDeclSyntax` specifically.
+  /// Visiting ``VariableDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `VariableDeclSyntax` and its descendents.
+  /// The function called after visiting ``VariableDeclSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: VariableDeclSyntax) {
   }
   
-  /// Visiting `VersionComponentListSyntax` specifically.
+  /// Visiting ``VersionComponentListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: VersionComponentListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `VersionComponentListSyntax` and its descendents.
+  /// The function called after visiting ``VersionComponentListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: VersionComponentListSyntax) {
   }
   
-  /// Visiting `VersionComponentSyntax` specifically.
+  /// Visiting ``VersionComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: VersionComponentSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `VersionComponentSyntax` and its descendents.
+  /// The function called after visiting ``VersionComponentSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: VersionComponentSyntax) {
   }
   
-  /// Visiting `VersionTupleSyntax` specifically.
+  /// Visiting ``VersionTupleSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: VersionTupleSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `VersionTupleSyntax` and its descendents.
+  /// The function called after visiting ``VersionTupleSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: VersionTupleSyntax) {
   }
   
-  /// Visiting `WhereClauseSyntax` specifically.
+  /// Visiting ``WhereClauseSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: WhereClauseSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `WhereClauseSyntax` and its descendents.
+  /// The function called after visiting ``WhereClauseSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: WhereClauseSyntax) {
   }
   
-  /// Visiting `WhileStmtSyntax` specifically.
+  /// Visiting ``WhileStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: WhileStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `WhileStmtSyntax` and its descendents.
+  /// The function called after visiting ``WhileStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: WhileStmtSyntax) {
   }
   
-  /// Visiting `WildcardPatternSyntax` specifically.
+  /// Visiting ``WildcardPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: WildcardPatternSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `WildcardPatternSyntax` and its descendents.
+  /// The function called after visiting ``WildcardPatternSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: WildcardPatternSyntax) {
   }
   
-  /// Visiting `YieldExprListElementSyntax` specifically.
+  /// Visiting ``YieldExprListElementSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: YieldExprListElementSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `YieldExprListElementSyntax` and its descendents.
+  /// The function called after visiting ``YieldExprListElementSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: YieldExprListElementSyntax) {
   }
   
-  /// Visiting `YieldExprListSyntax` specifically.
+  /// Visiting ``YieldExprListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: YieldExprListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `YieldExprListSyntax` and its descendents.
+  /// The function called after visiting ``YieldExprListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: YieldExprListSyntax) {
   }
   
-  /// Visiting `YieldListSyntax` specifically.
+  /// Visiting ``YieldListSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: YieldListSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `YieldListSyntax` and its descendents.
+  /// The function called after visiting ``YieldListSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: YieldListSyntax) {
   }
   
-  /// Visiting `YieldStmtSyntax` specifically.
+  /// Visiting ``YieldStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ node: YieldStmtSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
   
-  /// The function called after visiting `YieldStmtSyntax` and its descendents.
+  /// The function called after visiting ``YieldStmtSyntax`` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: YieldStmtSyntax) {
   }
   
-  /// Visiting `TokenSyntax` specifically.
+  /// Visiting ``TokenSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
   open func visit(_ token: TokenSyntax) -> SyntaxVisitorContinueKind {
diff --git a/Sources/SwiftSyntax/generated/TokenKind.swift b/Sources/SwiftSyntax/generated/TokenKind.swift
index b8e505ae838..be084f28a9d 100644
--- a/Sources/SwiftSyntax/generated/TokenKind.swift
+++ b/Sources/SwiftSyntax/generated/TokenKind.swift
@@ -858,7 +858,7 @@ extension TokenKind {
     }
   }
   
-  /// Returns the `RawTokenKind` of this `TokenKind` and, if this `TokenKind`
+  /// Returns the ``RawTokenKind`` of this ``TokenKind`` and, if this ``TokenKind``
   /// has associated text, the associated text, otherwise `nil`.
   @_spi(RawSyntax)
   public func decomposeToRaw() -> (rawKind: RawTokenKind, string: String?) {
diff --git a/Sources/SwiftSyntax/generated/TriviaPieces.swift b/Sources/SwiftSyntax/generated/TriviaPieces.swift
index 1308edf4d11..bcac304b1d5 100644
--- a/Sources/SwiftSyntax/generated/TriviaPieces.swift
+++ b/Sources/SwiftSyntax/generated/TriviaPieces.swift
@@ -13,7 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 /// A contiguous stretch of a single kind of trivia. The constituent part of
-/// a `Trivia` collection.
+/// a ``Trivia`` collection.
 ///
 /// For example, four spaces would be represented by
 /// `.spaces(4)`
@@ -299,7 +299,7 @@ extension TriviaPiece {
 
 /// Trivia piece for token RawSyntax.
 ///
-/// In contrast to `TriviaPiece`, a `RawTriviaPiece` does not own the source
+/// In contrast to ``TriviaPiece``, a ``RawTriviaPiece`` does not own the source
 /// text of a the trivia.
 @_spi(RawSyntax)
 public enum RawTriviaPiece: Equatable {
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift
index f9661548b6d..e075e638b30 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift
@@ -25,7 +25,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AccessorDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AccessorDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -114,7 +114,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -264,7 +264,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ActorDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ActorDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -365,7 +365,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -402,7 +402,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -596,7 +596,7 @@ public struct AssociatedtypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AssociatedtypeDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AssociatedtypeDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -692,7 +692,7 @@ public struct AssociatedtypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -730,7 +730,7 @@ public struct AssociatedtypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -907,7 +907,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ClassDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ClassDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1009,7 +1009,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -1047,7 +1047,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -1230,7 +1230,7 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DeinitializerDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DeinitializerDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1308,7 +1308,7 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -1346,7 +1346,7 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -1440,7 +1440,7 @@ public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `EditorPlaceholderDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``EditorPlaceholderDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1518,7 +1518,7 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `EnumCaseDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``EnumCaseDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1596,7 +1596,7 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -1634,7 +1634,7 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -1691,7 +1691,7 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Element` to the node's `elements`
+  /// Adds the provided `element` to the node's `elements`
   /// collection.
   /// - param element: The new `Element` to add to the node's
   ///                  `elements` collection.
@@ -1747,7 +1747,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `EnumDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``EnumDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1849,7 +1849,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -1887,7 +1887,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -2065,7 +2065,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ExtensionDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ExtensionDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2160,7 +2160,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -2197,7 +2197,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -2349,7 +2349,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `FunctionDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``FunctionDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2450,7 +2450,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -2487,7 +2487,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -2659,7 +2659,7 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `IfConfigDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``IfConfigDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2724,7 +2724,7 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Clause` to the node's `clauses`
+  /// Adds the provided `element` to the node's `clauses`
   /// collection.
   /// - param element: The new `Clause` to add to the node's
   ///                  `clauses` collection.
@@ -2798,7 +2798,7 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ImportDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ImportDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2882,7 +2882,7 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -2920,7 +2920,7 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -2996,7 +2996,7 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `PathComponent` to the node's `path`
+  /// Adds the provided `element` to the node's `path`
   /// collection.
   /// - param element: The new `PathComponent` to add to the node's
   ///                  `path` collection.
@@ -3061,7 +3061,7 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `InitializerDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``InitializerDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3163,7 +3163,7 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -3201,7 +3201,7 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -3379,7 +3379,7 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MacroDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MacroDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3480,7 +3480,7 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -3517,7 +3517,7 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -3689,7 +3689,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MacroExpansionDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MacroExpansionDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3802,7 +3802,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -3839,7 +3839,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -3949,7 +3949,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Argument` to the node's `argumentList`
+  /// Adds the provided `element` to the node's `argumentList`
   /// collection.
   /// - param element: The new `Argument` to add to the node's
   ///                  `argumentList` collection.
@@ -4022,7 +4022,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `AdditionalTrailingClosure` to the node's `additionalTrailingClosures`
+  /// Adds the provided `element` to the node's `additionalTrailingClosures`
   /// collection.
   /// - param element: The new `AdditionalTrailingClosure` to add to the node's
   ///                  `additionalTrailingClosures` collection.
@@ -4090,7 +4090,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MissingDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MissingDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4152,7 +4152,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// If there were standalone attributes without a declaration to attach them to, the `MissingDeclSyntax` will contain these.
+  /// If there were standalone attributes without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these.
   public var attributes: AttributeListSyntax? {
     get {
       return data.child(at: 1, parent: Syntax(self)).map(AttributeListSyntax.init)
@@ -4162,7 +4162,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -4190,7 +4190,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// If there were standalone modifiers without a declaration to attach them to, the `MissingDeclSyntax` will contain these.
+  /// If there were standalone modifiers without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these.
   public var modifiers: ModifierListSyntax? {
     get {
       return data.child(at: 3, parent: Syntax(self)).map(ModifierListSyntax.init)
@@ -4200,7 +4200,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -4273,7 +4273,7 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `OperatorDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``OperatorDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4443,7 +4443,7 @@ public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PoundSourceLocationSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PoundSourceLocationSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4611,7 +4611,7 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PrecedenceGroupDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PrecedenceGroupDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4707,7 +4707,7 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -4745,7 +4745,7 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -4838,7 +4838,7 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `GroupAttribute` to the node's `groupAttributes`
+  /// Adds the provided `element` to the node's `groupAttributes`
   /// collection.
   /// - param element: The new `GroupAttribute` to add to the node's
   ///                  `groupAttributes` collection.
@@ -4924,7 +4924,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ProtocolDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ProtocolDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5026,7 +5026,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -5064,7 +5064,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -5296,7 +5296,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `StructDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``StructDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5398,7 +5398,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -5436,7 +5436,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -5656,7 +5656,7 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SubscriptDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SubscriptDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5757,7 +5757,7 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -5794,7 +5794,7 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -5966,7 +5966,7 @@ public struct TypealiasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TypealiasDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TypealiasDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6061,7 +6061,7 @@ public struct TypealiasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -6098,7 +6098,7 @@ public struct TypealiasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -6250,7 +6250,7 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `VariableDeclSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``VariableDeclSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6327,7 +6327,7 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -6364,7 +6364,7 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -6419,7 +6419,7 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Binding` to the node's `bindings`
+  /// Adds the provided `element` to the node's `bindings`
   /// collection.
   /// - param element: The new `Binding` to add to the node's
   ///                  `bindings` collection.
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift
index 40de38c9a1c..0f83f321fb9 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift
@@ -25,7 +25,7 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ArrayExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ArrayExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -114,7 +114,7 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Element` to the node's `elements`
+  /// Adds the provided `element` to the node's `elements`
   /// collection.
   /// - param element: The new `Element` to add to the node's
   ///                  `elements` collection.
@@ -186,7 +186,7 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ArrowExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ArrowExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -302,7 +302,7 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AsExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AsExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -470,7 +470,7 @@ public struct AssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AssignmentExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AssignmentExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -548,7 +548,7 @@ public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AwaitExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AwaitExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -664,7 +664,7 @@ public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `BinaryOperatorExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``BinaryOperatorExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -742,7 +742,7 @@ public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `BooleanLiteralExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``BooleanLiteralExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -820,7 +820,7 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `BorrowExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``BorrowExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -936,7 +936,7 @@ public struct CanImportExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `CanImportExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``CanImportExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1130,7 +1130,7 @@ public struct CanImportVersionInfoSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `CanImportVersionInfoSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``CanImportVersionInfoSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1298,7 +1298,7 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ClosureExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ClosureExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1411,7 +1411,7 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Statement` to the node's `statements`
+  /// Adds the provided `element` to the node's `statements`
   /// collection.
   /// - param element: The new `Statement` to add to the node's
   ///                  `statements` collection.
@@ -1485,7 +1485,7 @@ public struct CopyExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `CopyExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``CopyExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1643,7 +1643,7 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DictionaryExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DictionaryExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1785,7 +1785,7 @@ public struct DiscardAssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DiscardAssignmentExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DiscardAssignmentExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1863,7 +1863,7 @@ public struct EditorPlaceholderExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `EditorPlaceholderExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``EditorPlaceholderExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1941,7 +1941,7 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `FloatLiteralExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``FloatLiteralExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2019,7 +2019,7 @@ public struct ForcedValueExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ForcedValueExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ForcedValueExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2135,7 +2135,7 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `FunctionCallExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``FunctionCallExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2260,7 +2260,7 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Argument` to the node's `argumentList`
+  /// Adds the provided `element` to the node's `argumentList`
   /// collection.
   /// - param element: The new `Argument` to add to the node's
   ///                  `argumentList` collection.
@@ -2333,7 +2333,7 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `AdditionalTrailingClosure` to the node's `additionalTrailingClosures`
+  /// Adds the provided `element` to the node's `additionalTrailingClosures`
   /// collection.
   /// - param element: The new `AdditionalTrailingClosure` to add to the node's
   ///                  `additionalTrailingClosures` collection.
@@ -2393,7 +2393,7 @@ public struct IdentifierExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `IdentifierExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``IdentifierExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2551,7 +2551,7 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `IfExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``IfExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2652,7 +2652,7 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Condition` to the node's `conditions`
+  /// Adds the provided `element` to the node's `conditions`
   /// collection.
   /// - param element: The new `Condition` to add to the node's
   ///                  `conditions` collection.
@@ -2764,7 +2764,7 @@ public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `InOutExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``InOutExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2880,7 +2880,7 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `InfixOperatorExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``InfixOperatorExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3022,7 +3022,7 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `IntegerLiteralExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``IntegerLiteralExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3106,7 +3106,7 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `IsExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``IsExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3251,7 +3251,7 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `KeyPathExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``KeyPathExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3358,7 +3358,7 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `KeyPathComponent` to the node's `components`
+  /// Adds the provided `element` to the node's `components`
   /// collection.
   /// - param element: The new `KeyPathComponent` to add to the node's
   ///                  `components` collection.
@@ -3412,7 +3412,7 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MacroExpansionExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MacroExpansionExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3586,7 +3586,7 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Argument` to the node's `argumentList`
+  /// Adds the provided `element` to the node's `argumentList`
   /// collection.
   /// - param element: The new `Argument` to add to the node's
   ///                  `argumentList` collection.
@@ -3659,7 +3659,7 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `AdditionalTrailingClosure` to the node's `additionalTrailingClosures`
+  /// Adds the provided `element` to the node's `additionalTrailingClosures`
   /// collection.
   /// - param element: The new `AdditionalTrailingClosure` to add to the node's
   ///                  `additionalTrailingClosures` collection.
@@ -3723,7 +3723,7 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MemberAccessExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MemberAccessExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3891,7 +3891,7 @@ public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MissingExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MissingExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3970,7 +3970,7 @@ public struct MoveExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MoveExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MoveExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4086,7 +4086,7 @@ public struct NilLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `NilLiteralExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``NilLiteralExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4164,7 +4164,7 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `OptionalChainingExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``OptionalChainingExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4280,7 +4280,7 @@ public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PackElementExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PackElementExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4396,7 +4396,7 @@ public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PackExpansionExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PackExpansionExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4512,7 +4512,7 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PostfixIfConfigExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PostfixIfConfigExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4628,7 +4628,7 @@ public struct PostfixUnaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PostfixUnaryExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PostfixUnaryExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4744,7 +4744,7 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PrefixOperatorExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PrefixOperatorExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4860,7 +4860,7 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `RegexLiteralExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``RegexLiteralExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5054,7 +5054,7 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SequenceExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SequenceExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5105,7 +5105,7 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Element` to the node's `elements`
+  /// Adds the provided `element` to the node's `elements`
   /// collection.
   /// - param element: The new `Element` to add to the node's
   ///                  `elements` collection.
@@ -5151,7 +5151,7 @@ public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SpecializeExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SpecializeExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5267,7 +5267,7 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `StringLiteralExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``StringLiteralExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5386,7 +5386,7 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Segment` to the node's `segments`
+  /// Adds the provided `element` to the node's `segments`
   /// collection.
   /// - param element: The new `Segment` to add to the node's
   ///                  `segments` collection.
@@ -5480,7 +5480,7 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SubscriptExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SubscriptExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5605,7 +5605,7 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Argument` to the node's `argumentList`
+  /// Adds the provided `element` to the node's `argumentList`
   /// collection.
   /// - param element: The new `Argument` to add to the node's
   ///                  `argumentList` collection.
@@ -5678,7 +5678,7 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `AdditionalTrailingClosure` to the node's `additionalTrailingClosures`
+  /// Adds the provided `element` to the node's `additionalTrailingClosures`
   /// collection.
   /// - param element: The new `AdditionalTrailingClosure` to add to the node's
   ///                  `additionalTrailingClosures` collection.
@@ -5738,7 +5738,7 @@ public struct SuperRefExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SuperRefExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SuperRefExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5816,7 +5816,7 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SwitchExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SwitchExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5953,7 +5953,7 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Case` to the node's `cases`
+  /// Adds the provided `element` to the node's `cases`
   /// collection.
   /// - param element: The new `Case` to add to the node's
   ///                  `cases` collection.
@@ -6029,7 +6029,7 @@ public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TernaryExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TernaryExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6223,7 +6223,7 @@ public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TryExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TryExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6365,7 +6365,7 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TupleExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TupleExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6454,7 +6454,7 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Element` to the node's `elements`
+  /// Adds the provided `element` to the node's `elements`
   /// collection.
   /// - param element: The new `Element` to add to the node's
   ///                  `elements` collection.
@@ -6526,7 +6526,7 @@ public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TypeExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TypeExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6604,7 +6604,7 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `UnresolvedAsExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``UnresolvedAsExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6720,7 +6720,7 @@ public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `UnresolvedIsExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``UnresolvedIsExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6798,7 +6798,7 @@ public struct UnresolvedPatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `UnresolvedPatternExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``UnresolvedPatternExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6876,7 +6876,7 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `UnresolvedTernaryExprSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``UnresolvedTernaryExprSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift
index 3c8c684bf08..9477bd63355 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift
@@ -25,7 +25,7 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AccessorBlockSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AccessorBlockSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -114,7 +114,7 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Accessor` to the node's `accessors`
+  /// Adds the provided `element` to the node's `accessors`
   /// collection.
   /// - param element: The new `Accessor` to add to the node's
   ///                  `accessors` collection.
@@ -186,7 +186,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AccessorEffectSpecifiersSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AccessorEffectSpecifiersSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -302,7 +302,7 @@ public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AccessorParameterSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AccessorParameterSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -444,7 +444,7 @@ public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ArrayElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ArrayElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -821,7 +821,7 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AttributeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AttributeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1073,7 +1073,7 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AvailabilityArgumentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AvailabilityArgumentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1191,7 +1191,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AvailabilityConditionSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AvailabilityConditionSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1304,7 +1304,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `AvailabilityArgument` to the node's `availabilitySpec`
+  /// Adds the provided `element` to the node's `availabilitySpec`
   /// collection.
   /// - param element: The new `AvailabilityArgument` to add to the node's
   ///                  `availabilitySpec` collection.
@@ -1378,7 +1378,7 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AvailabilityEntrySyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AvailabilityEntrySyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1493,7 +1493,7 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Availability` to the node's `availabilityList`
+  /// Adds the provided `element` to the node's `availabilityList`
   /// collection.
   /// - param element: The new `Availability` to add to the node's
   ///                  `availabilityList` collection.
@@ -1609,7 +1609,7 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AvailabilityLabeledArgumentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AvailabilityLabeledArgumentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1754,7 +1754,7 @@ public struct AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, Syn
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AvailabilityVersionRestrictionListEntrySyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AvailabilityVersionRestrictionListEntrySyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1871,7 +1871,7 @@ public struct AvailabilityVersionRestrictionSyntax: SyntaxProtocol, SyntaxHashab
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AvailabilityVersionRestrictionSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AvailabilityVersionRestrictionSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1988,7 +1988,7 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `BackDeployedAttributeSpecListSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``BackDeployedAttributeSpecListSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2098,7 +2098,7 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl
     }
   }
   
-  /// Adds the provided `Availability` to the node's `versionList`
+  /// Adds the provided `element` to the node's `versionList`
   /// collection.
   /// - param element: The new `Availability` to add to the node's
   ///                  `versionList` collection.
@@ -2152,7 +2152,7 @@ public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `CaseItemSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``CaseItemSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2294,7 +2294,7 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `CatchClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``CatchClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2383,7 +2383,7 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `CatchItem` to the node's `catchItems`
+  /// Adds the provided `element` to the node's `catchItems`
   /// collection.
   /// - param element: The new `CatchItem` to add to the node's
   ///                  `catchItems` collection.
@@ -2455,7 +2455,7 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `CatchItemSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``CatchItemSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2597,7 +2597,7 @@ public struct ClosureCaptureItemSpecifierSyntax: SyntaxProtocol, SyntaxHashable
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ClosureCaptureItemSpecifierSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ClosureCaptureItemSpecifierSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2765,7 +2765,7 @@ public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ClosureCaptureItemSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ClosureCaptureItemSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2959,7 +2959,7 @@ public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ClosureCaptureSignatureSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ClosureCaptureSignatureSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3048,7 +3048,7 @@ public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Item` to the node's `items`
+  /// Adds the provided `element` to the node's `items`
   /// collection.
   /// - param element: The new `Item` to add to the node's
   ///                  `items` collection.
@@ -3120,7 +3120,7 @@ public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ClosureParamSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ClosureParamSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3236,7 +3236,7 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ClosureParameterClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ClosureParameterClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3327,7 +3327,7 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Parameter` to the node's `parameterList`
+  /// Adds the provided `element` to the node's `parameterList`
   /// collection.
   /// - param element: The new `Parameter` to add to the node's
   ///                  `parameterList` collection.
@@ -3400,7 +3400,7 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ClosureParameterSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ClosureParameterSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3501,7 +3501,7 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -3538,7 +3538,7 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -3758,7 +3758,7 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ClosureSignatureSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ClosureSignatureSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -3847,7 +3847,7 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -4050,7 +4050,7 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `CodeBlockItemSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``CodeBlockItemSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4168,7 +4168,7 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `CodeBlockSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``CodeBlockSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4257,7 +4257,7 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Statement` to the node's `statements`
+  /// Adds the provided `element` to the node's `statements`
   /// collection.
   /// - param element: The new `Statement` to add to the node's
   ///                  `statements` collection.
@@ -4329,7 +4329,7 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `CompositionTypeElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``CompositionTypeElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4514,7 +4514,7 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ConditionElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ConditionElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4630,7 +4630,7 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ConformanceRequirementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ConformanceRequirementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4772,7 +4772,7 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ConventionAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ConventionAttributeArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -4967,7 +4967,7 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ConventionWitnessMethodAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ConventionWitnessMethodAttributeArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5109,7 +5109,7 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DeclModifierDetailSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DeclModifierDetailSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5251,7 +5251,7 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DeclModifierSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DeclModifierSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5367,7 +5367,7 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DeclNameArgumentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DeclNameArgumentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5483,7 +5483,7 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DeclNameArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DeclNameArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5572,7 +5572,7 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Argument` to the node's `arguments`
+  /// Adds the provided `element` to the node's `arguments`
   /// collection.
   /// - param element: The new `Argument` to add to the node's
   ///                  `arguments` collection.
@@ -5644,7 +5644,7 @@ public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DeclNameSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DeclNameSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -5762,7 +5762,7 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DerivativeRegistrationAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DerivativeRegistrationAttributeArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6013,7 +6013,7 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DesignatedTypeElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DesignatedTypeElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6129,7 +6129,7 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DictionaryElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DictionaryElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6297,7 +6297,7 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DifferentiabilityParamSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DifferentiabilityParamSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6455,7 +6455,7 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DifferentiabilityParamsClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DifferentiabilityParamsClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6599,7 +6599,7 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DifferentiabilityParamsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DifferentiabilityParamsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6689,7 +6689,7 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `DifferentiabilityParam` to the node's `diffParams`
+  /// Adds the provided `element` to the node's `diffParams`
   /// collection.
   /// - param element: The new `DifferentiabilityParam` to add to the node's
   ///                  `diffParams` collection.
@@ -6761,7 +6761,7 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DifferentiableAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DifferentiableAttributeArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -6999,7 +6999,7 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DocumentationAttributeArgumentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DocumentationAttributeArgumentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -7168,7 +7168,7 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DynamicReplacementArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DynamicReplacementArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -7310,7 +7310,7 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `EnumCaseElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``EnumCaseElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -7482,7 +7482,7 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `EnumCaseParameterClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``EnumCaseParameterClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -7573,7 +7573,7 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Parameter` to the node's `parameterList`
+  /// Adds the provided `element` to the node's `parameterList`
   /// collection.
   /// - param element: The new `Parameter` to add to the node's
   ///                  `parameterList` collection.
@@ -7646,7 +7646,7 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `EnumCaseParameterSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``EnumCaseParameterSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -7741,7 +7741,7 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -7915,7 +7915,7 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ExposeAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ExposeAttributeArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -8057,7 +8057,7 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ExpressionSegmentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ExpressionSegmentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -8194,7 +8194,7 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Expression` to the node's `expressions`
+  /// Adds the provided `element` to the node's `expressions`
   /// collection.
   /// - param element: The new `Expression` to add to the node's
   ///                  `expressions` collection.
@@ -8270,7 +8270,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `FunctionEffectSpecifiersSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``FunctionEffectSpecifiersSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -8386,7 +8386,7 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `FunctionParameterSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``FunctionParameterSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -8493,7 +8493,7 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -8530,7 +8530,7 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Modifier` to the node's `modifiers`
+  /// Adds the provided `element` to the node's `modifiers`
   /// collection.
   /// - param element: The new `Modifier` to add to the node's
   ///                  `modifiers` collection.
@@ -8722,7 +8722,7 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `FunctionSignatureSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``FunctionSignatureSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -8864,7 +8864,7 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `GenericArgumentClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``GenericArgumentClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -8953,7 +8953,7 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Argument` to the node's `arguments`
+  /// Adds the provided `element` to the node's `arguments`
   /// collection.
   /// - param element: The new `Argument` to add to the node's
   ///                  `arguments` collection.
@@ -9025,7 +9025,7 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `GenericArgumentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``GenericArgumentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -9141,7 +9141,7 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `GenericParameterClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``GenericParameterClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -9236,7 +9236,7 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `GenericParameter` to the node's `genericParameterList`
+  /// Adds the provided `element` to the node's `genericParameterList`
   /// collection.
   /// - param element: The new `GenericParameter` to add to the node's
   ///                  `genericParameterList` collection.
@@ -9328,7 +9328,7 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `GenericParameterSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``GenericParameterSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -9417,7 +9417,7 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -9620,7 +9620,7 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `GenericRequirementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``GenericRequirementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -9736,7 +9736,7 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `GenericWhereClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``GenericWhereClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -9819,7 +9819,7 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Requirement` to the node's `requirementList`
+  /// Adds the provided `element` to the node's `requirementList`
   /// collection.
   /// - param element: The new `Requirement` to add to the node's
   ///                  `requirementList` collection.
@@ -9952,7 +9952,7 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `IfConfigClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``IfConfigClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -10094,7 +10094,7 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ImplementsAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ImplementsAttributeArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -10266,7 +10266,7 @@ public struct ImportPathComponentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ImportPathComponentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ImportPathComponentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -10382,7 +10382,7 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `InheritedTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``InheritedTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -10498,7 +10498,7 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `InitializerClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``InitializerClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -10667,7 +10667,7 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `KeyPathComponentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``KeyPathComponentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -10783,7 +10783,7 @@ public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `KeyPathOptionalComponentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``KeyPathOptionalComponentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -10861,7 +10861,7 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `KeyPathPropertyComponentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``KeyPathPropertyComponentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -11003,7 +11003,7 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `KeyPathSubscriptComponentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``KeyPathSubscriptComponentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -11092,7 +11092,7 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Argument` to the node's `argumentList`
+  /// Adds the provided `element` to the node's `argumentList`
   /// collection.
   /// - param element: The new `Argument` to add to the node's
   ///                  `argumentList` collection.
@@ -11164,7 +11164,7 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `LabeledSpecializeEntrySyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``LabeledSpecializeEntrySyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -11336,7 +11336,7 @@ public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `LayoutRequirementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``LayoutRequirementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -11608,7 +11608,7 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MatchingPatternConditionSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MatchingPatternConditionSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -11776,7 +11776,7 @@ public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MemberDeclBlockSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MemberDeclBlockSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -11865,7 +11865,7 @@ public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Member` to the node's `members`
+  /// Adds the provided `element` to the node's `members`
   /// collection.
   /// - param element: The new `Member` to add to the node's
   ///                  `members` collection.
@@ -11937,7 +11937,7 @@ public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MemberDeclListItemSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MemberDeclListItemSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -12055,7 +12055,7 @@ public struct MissingSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MissingSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MissingSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -12134,7 +12134,7 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MultipleTrailingClosureElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MultipleTrailingClosureElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -12276,7 +12276,7 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ObjCSelectorPieceSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ObjCSelectorPieceSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -12392,7 +12392,7 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `OpaqueReturnTypeOfAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -12536,7 +12536,7 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `OperatorPrecedenceAndTypesSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``OperatorPrecedenceAndTypesSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -12645,7 +12645,7 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `DesignatedTypeElement` to the node's `designatedTypes`
+  /// Adds the provided `element` to the node's `designatedTypes`
   /// collection.
   /// - param element: The new `DesignatedTypeElement` to add to the node's
   ///                  `designatedTypes` collection.
@@ -12699,7 +12699,7 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `OptionalBindingConditionSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``OptionalBindingConditionSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -12867,7 +12867,7 @@ public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `OriginallyDefinedInArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``OriginallyDefinedInArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -13022,7 +13022,7 @@ public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable
     }
   }
   
-  /// Adds the provided `Platform` to the node's `platforms`
+  /// Adds the provided `element` to the node's `platforms`
   /// collection.
   /// - param element: The new `Platform` to add to the node's
   ///                  `platforms` collection.
@@ -13080,7 +13080,7 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ParameterClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ParameterClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -13169,7 +13169,7 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Parameter` to the node's `parameterList`
+  /// Adds the provided `element` to the node's `parameterList`
   /// collection.
   /// - param element: The new `Parameter` to add to the node's
   ///                  `parameterList` collection.
@@ -13283,7 +13283,7 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PatternBindingSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PatternBindingSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -13477,7 +13477,7 @@ public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PoundSourceLocationArgsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PoundSourceLocationArgsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -13723,7 +13723,7 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PrecedenceGroupAssignmentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PrecedenceGroupAssignmentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -13866,7 +13866,7 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PrecedenceGroupAssociativitySyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PrecedenceGroupAssociativitySyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -14009,7 +14009,7 @@ public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PrecedenceGroupNameElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PrecedenceGroupNameElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -14125,7 +14125,7 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PrecedenceGroupRelationSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PrecedenceGroupRelationSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -14234,7 +14234,7 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `OtherName` to the node's `otherNames`
+  /// Adds the provided `element` to the node's `otherNames`
   /// collection.
   /// - param element: The new `OtherName` to add to the node's
   ///                  `otherNames` collection.
@@ -14288,7 +14288,7 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PrimaryAssociatedTypeClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PrimaryAssociatedTypeClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -14377,7 +14377,7 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable
     }
   }
   
-  /// Adds the provided `PrimaryAssociatedType` to the node's `primaryAssociatedTypeList`
+  /// Adds the provided `element` to the node's `primaryAssociatedTypeList`
   /// collection.
   /// - param element: The new `PrimaryAssociatedType` to add to the node's
   ///                  `primaryAssociatedTypeList` collection.
@@ -14449,7 +14449,7 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PrimaryAssociatedTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PrimaryAssociatedTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -14565,7 +14565,7 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `QualifiedDeclNameSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``QualifiedDeclNameSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -14736,7 +14736,7 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ReturnClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ReturnClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -14852,7 +14852,7 @@ public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SameTypeRequirementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SameTypeRequirementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -14994,7 +14994,7 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SourceFileSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SourceFileSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -15059,7 +15059,7 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Statement` to the node's `statements`
+  /// Adds the provided `element` to the node's `statements`
   /// collection.
   /// - param element: The new `Statement` to add to the node's
   ///                  `statements` collection.
@@ -15129,7 +15129,7 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `StringSegmentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``StringSegmentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -15207,7 +15207,7 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SwitchCaseLabelSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SwitchCaseLabelSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -15296,7 +15296,7 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `CaseItem` to the node's `caseItems`
+  /// Adds the provided `element` to the node's `caseItems`
   /// collection.
   /// - param element: The new `CaseItem` to add to the node's
   ///                  `caseItems` collection.
@@ -15410,7 +15410,7 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SwitchCaseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SwitchCaseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -15517,7 +15517,7 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Statement` to the node's `statements`
+  /// Adds the provided `element` to the node's `statements`
   /// collection.
   /// - param element: The new `Statement` to add to the node's
   ///                  `statements` collection.
@@ -15571,7 +15571,7 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SwitchDefaultLabelSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SwitchDefaultLabelSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -15687,7 +15687,7 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TargetFunctionEntrySyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TargetFunctionEntrySyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -15859,7 +15859,7 @@ public struct TupleExprElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TupleExprElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TupleExprElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -16027,7 +16027,7 @@ public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TuplePatternElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TuplePatternElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -16195,7 +16195,7 @@ public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TupleTypeElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TupleTypeElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -16467,7 +16467,7 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TypeAnnotationSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TypeAnnotationSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -16583,7 +16583,7 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TypeEffectSpecifiersSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TypeEffectSpecifiersSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -16699,7 +16699,7 @@ public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TypeInheritanceClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TypeInheritanceClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -16782,7 +16782,7 @@ public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `InheritedType` to the node's `inheritedTypeCollection`
+  /// Adds the provided `element` to the node's `inheritedTypeCollection`
   /// collection.
   /// - param element: The new `InheritedType` to add to the node's
   ///                  `inheritedTypeCollection` collection.
@@ -16834,7 +16834,7 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TypeInitializerClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TypeInitializerClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -16950,7 +16950,7 @@ public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashabl
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `UnavailableFromAsyncArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``UnavailableFromAsyncArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -17092,7 +17092,7 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `UnderscorePrivateAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``UnderscorePrivateAttributeArgumentsSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -17234,7 +17234,7 @@ public struct VersionComponentSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `VersionComponentSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``VersionComponentSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -17352,7 +17352,7 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `VersionTupleSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``VersionTupleSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -17437,7 +17437,7 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `VersionComponent` to the node's `components`
+  /// Adds the provided `element` to the node's `components`
   /// collection.
   /// - param element: The new `VersionComponent` to add to the node's
   ///                  `components` collection.
@@ -17489,7 +17489,7 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `WhereClauseSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``WhereClauseSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -17605,7 +17605,7 @@ public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `YieldExprListElementSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``YieldExprListElementSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -17721,7 +17721,7 @@ public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `YieldListSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``YieldListSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -17810,7 +17810,7 @@ public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Element` to the node's `elementList`
+  /// Adds the provided `element` to the node's `elementList`
   /// collection.
   /// - param element: The new `Element` to add to the node's
   ///                  `elementList` collection.
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift
index fcc18d04343..67db26c172c 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift
@@ -25,7 +25,7 @@ public struct ExpressionPatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ExpressionPatternSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ExpressionPatternSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -103,7 +103,7 @@ public struct IdentifierPatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `IdentifierPatternSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``IdentifierPatternSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -181,7 +181,7 @@ public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `IsTypePatternSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``IsTypePatternSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -297,7 +297,7 @@ public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MissingPatternSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MissingPatternSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -376,7 +376,7 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TuplePatternSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TuplePatternSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -465,7 +465,7 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Element` to the node's `elements`
+  /// Adds the provided `element` to the node's `elements`
   /// collection.
   /// - param element: The new `Element` to add to the node's
   ///                  `elements` collection.
@@ -537,7 +537,7 @@ public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ValueBindingPatternSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ValueBindingPatternSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -653,7 +653,7 @@ public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `WildcardPatternSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``WildcardPatternSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift
index 47f447af21a..1f16edd40b1 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift
@@ -25,7 +25,7 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `BreakStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``BreakStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -141,7 +141,7 @@ public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ContinueStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ContinueStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -257,7 +257,7 @@ public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DeferStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DeferStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -373,7 +373,7 @@ public struct DiscardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DiscardStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DiscardStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -489,7 +489,7 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DoStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DoStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -596,7 +596,7 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `CatchClause` to the node's `catchClauses`
+  /// Adds the provided `element` to the node's `catchClauses`
   /// collection.
   /// - param element: The new `CatchClause` to add to the node's
   ///                  `catchClauses` collection.
@@ -650,7 +650,7 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ExpressionStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ExpressionStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -728,7 +728,7 @@ public struct FallthroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `FallthroughStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``FallthroughStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -806,7 +806,7 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ForInStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ForInStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1130,7 +1130,7 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `GuardStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``GuardStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1225,7 +1225,7 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Condition` to the node's `conditions`
+  /// Adds the provided `element` to the node's `conditions`
   /// collection.
   /// - param element: The new `Condition` to add to the node's
   ///                  `conditions` collection.
@@ -1317,7 +1317,7 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `LabeledStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``LabeledStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1459,7 +1459,7 @@ public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MissingStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MissingStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1538,7 +1538,7 @@ public struct RepeatWhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `RepeatWhileStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``RepeatWhileStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1706,7 +1706,7 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ReturnStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ReturnStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1822,7 +1822,7 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ThrowStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ThrowStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1938,7 +1938,7 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `WhileStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``WhileStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2027,7 +2027,7 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Condition` to the node's `conditions`
+  /// Adds the provided `element` to the node's `conditions`
   /// collection.
   /// - param element: The new `Condition` to add to the node's
   ///                  `conditions` collection.
@@ -2141,7 +2141,7 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `YieldStmtSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``YieldStmtSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift
index 02aeaa3cedc..295e54edb37 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift
@@ -25,7 +25,7 @@ public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ArrayTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ArrayTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -167,7 +167,7 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `AttributedTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``AttributedTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -256,7 +256,7 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Attribute` to the node's `attributes`
+  /// Adds the provided `element` to the node's `attributes`
   /// collection.
   /// - param element: The new `Attribute` to add to the node's
   ///                  `attributes` collection.
@@ -328,7 +328,7 @@ public struct ClassRestrictionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ClassRestrictionTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ClassRestrictionTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -406,7 +406,7 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `CompositionTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``CompositionTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -457,7 +457,7 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Element` to the node's `elements`
+  /// Adds the provided `element` to the node's `elements`
   /// collection.
   /// - param element: The new `Element` to add to the node's
   ///                  `elements` collection.
@@ -503,7 +503,7 @@ public struct ConstrainedSugarTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ConstrainedSugarTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ConstrainedSugarTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -619,7 +619,7 @@ public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `DictionaryTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``DictionaryTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -813,7 +813,7 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `FunctionTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``FunctionTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -914,7 +914,7 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Argument` to the node's `arguments`
+  /// Adds the provided `element` to the node's `arguments`
   /// collection.
   /// - param element: The new `Argument` to add to the node's
   ///                  `arguments` collection.
@@ -1026,7 +1026,7 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `ImplicitlyUnwrappedOptionalTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``ImplicitlyUnwrappedOptionalTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1142,7 +1142,7 @@ public struct MemberTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MemberTypeIdentifierSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MemberTypeIdentifierSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1310,7 +1310,7 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MetatypeTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MetatypeTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1452,7 +1452,7 @@ public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `MissingTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``MissingTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1531,7 +1531,7 @@ public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `NamedOpaqueReturnTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``NamedOpaqueReturnTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1647,7 +1647,7 @@ public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `OptionalTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``OptionalTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1763,7 +1763,7 @@ public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PackExpansionTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PackExpansionTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1879,7 +1879,7 @@ public struct PackReferenceTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `PackReferenceTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``PackReferenceTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -1995,7 +1995,7 @@ public struct SimpleTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SimpleTypeIdentifierSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SimpleTypeIdentifierSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2111,7 +2111,7 @@ public struct SuppressedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `SuppressedTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``SuppressedTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2227,7 +2227,7 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = node._syntaxNode
   }
   
-  /// Creates a `TupleTypeSyntax` node from the given `SyntaxData`. This assumes
+  /// Creates a ``TupleTypeSyntax`` node from the given ``SyntaxData``. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
   internal init(_ data: SyntaxData) {
@@ -2316,7 +2316,7 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     }
   }
   
-  /// Adds the provided `Element` to the node's `elements`
+  /// Adds the provided `element` to the node's `elements`
   /// collection.
   /// - param element: The new `Element` to add to the node's
   ///                  `elements` collection.
diff --git a/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift b/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift
index 6d1f8db6a55..d092d2cfda2 100644
--- a/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift
+++ b/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift
@@ -149,7 +149,7 @@ enum SyntaxStringInterpolationError: Error, CustomStringConvertible {
       return "Parsing the code snippet was expected to produce a \(expectedType) but produced a \(actualType)"
     case .diagnostics(let diagnostics, let tree):
       // Start the diagnostic on a new line so it isn't prefixed with the file, which messes up the
-      // column-aligned message from `DiagnosticsFormatter`.
+      // column-aligned message from ``DiagnosticsFormatter``.
       return "\n" + DiagnosticsFormatter.annotatedSource(tree: tree, diags: diagnostics)
     }
   }
@@ -161,7 +161,7 @@ enum SyntaxStringInterpolationError: Error, CustomStringConvertible {
 /// Conforming types do not *contain* Swift source code; rather, they can be
 /// *expressed* in Swift source code, and this protocol can be used to get
 /// whatever source code would do that. For example, `String` is
-/// `ExpressibleByLiteralSyntax` but `StringLiteralExprSyntax` is not.
+/// `ExpressibleByLiteralSyntax` but ``StringLiteralExprSyntax`` is not.
 ///
 /// This protocol is usually not used directly. Instead, conforming types can
 /// be turned into syntax trees using ``Expr/init(literal:)``:
diff --git a/Sources/SwiftSyntaxBuilder/ValidatingSyntaxNodes.swift b/Sources/SwiftSyntaxBuilder/ValidatingSyntaxNodes.swift
index 152d422a9d6..13cb7f80e16 100644
--- a/Sources/SwiftSyntaxBuilder/ValidatingSyntaxNodes.swift
+++ b/Sources/SwiftSyntaxBuilder/ValidatingSyntaxNodes.swift
@@ -19,7 +19,7 @@ extension SyntaxProtocol {
   /// throw an error with diagnostics describing the syntax errors.
   ///
   /// This allows clients to e.g. write `try DeclSyntax(validating: "struct Foo {}")`
-  /// which constructs a `DeclSyntax` that's guaranteed to be free of syntax
+  /// which constructs a ``DeclSyntax`` that's guaranteed to be free of syntax
   /// errors.
   public init(validating node: Self) throws {
     if node.hasError {
diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift
index 1e05764984b..a87a35c0286 100644
--- a/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift
+++ b/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift
@@ -168,7 +168,7 @@ extension EnumCaseParameterListSyntax: ExpressibleByArrayLiteral {
   }
 }
 
-/// A list of expressions connected by operators. This list is contained by a `SequenceExprSyntax`.
+/// A list of expressions connected by operators. This list is contained by a ``SequenceExprSyntax``.
 extension ExprListSyntax: ExpressibleByArrayLiteral {
   public init(_ elements: [ExprSyntaxProtocol]) {
     self = ExprListSyntax(elements.map {
diff --git a/Sources/SwiftSyntaxMacros/MacroSystem.swift b/Sources/SwiftSyntaxMacros/MacroSystem.swift
index 3e474271c79..c17f89cbd6b 100644
--- a/Sources/SwiftSyntaxMacros/MacroSystem.swift
+++ b/Sources/SwiftSyntaxMacros/MacroSystem.swift
@@ -65,7 +65,7 @@ class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
   var context: Context
   var skipNodes: Set<Syntax> = []
 
-  /// A stack of member attribute macos to expand when iterating over a `MemberDeclListSyntax`.
+  /// A stack of member attribute macos to expand when iterating over a ``MemberDeclListSyntax``.
   var memberAttributeMacros: [([(AttributeSyntax, MemberAttributeMacro.Type)], DeclSyntax)] = []
 
   init(
diff --git a/Sources/SwiftSyntaxMacrosTestSupport/Assertions.swift b/Sources/SwiftSyntaxMacrosTestSupport/Assertions.swift
index bfc4f39889c..087b4671006 100644
--- a/Sources/SwiftSyntaxMacrosTestSupport/Assertions.swift
+++ b/Sources/SwiftSyntaxMacrosTestSupport/Assertions.swift
@@ -31,18 +31,18 @@ public struct NoteSpec {
   /// The column to which the note is expected to point
   public let column: Int
 
-  /// The file and line at which this `NoteSpec` was created, so that assertion failures can be reported at its location.
+  /// The file and line at which this ``NoteSpec`` was created, so that assertion failures can be reported at its location.
   internal let originatorFile: StaticString
   internal let originatorLine: UInt
 
-  /// Creates a new `NoteSpec` that describes a note tests are expecting to be generated by a macro expansion.
+  /// Creates a new ``NoteSpec`` that describes a note tests are expecting to be generated by a macro expansion.
   ///
   /// - Parameters:
   ///   - message: The expected message of the note
   ///   - line: The line to which the note is expected to point
   ///   - column: The column to which the note is expected to point
-  ///   - originatorFile: The file at which this `NoteSpec` was created, so that assertion failures can be reported at its location.
-  ///   - originatorLine: The line at which this `NoteSpec` was created, so that assertion failures can be reported at its location.
+  ///   - originatorFile: The file at which this ``NoteSpec`` was created, so that assertion failures can be reported at its location.
+  ///   - originatorLine: The line at which this ``NoteSpec`` was created, so that assertion failures can be reported at its location.
   public init(
     message: String,
     line: Int,
@@ -79,16 +79,16 @@ public struct FixItSpec {
   /// The expected message of the Fix-It
   public let message: String
 
-  /// The file and line at which this `NoteSpec` was created, so that assertion failures can be reported at its location.
+  /// The file and line at which this ``NoteSpec`` was created, so that assertion failures can be reported at its location.
   internal let originatorFile: StaticString
   internal let originatorLine: UInt
 
-  /// Creates a new `FixItSpec` that describes a Fix-It tests are expecting to be generated by a macro expansion.
+  /// Creates a new ``FixItSpec`` that describes a Fix-It tests are expecting to be generated by a macro expansion.
   ///
   /// - Parameters:
   ///   - message: The expected message of the note
-  ///   - originatorFile: The file at which this `NoteSpec` was created, so that assertion failures can be reported at its location.
-  ///   - originatorLine: The line at which this `NoteSpec` was created, so that assertion failures can be reported at its location.
+  ///   - originatorFile: The file at which this ``NoteSpec`` was created, so that assertion failures can be reported at its location.
+  ///   - originatorLine: The line at which this ``NoteSpec`` was created, so that assertion failures can be reported at its location.
   public init(
     message: String,
     originatorFile: StaticString = #file,
@@ -135,11 +135,11 @@ public struct DiagnosticSpec {
   /// The messages of the Fix-Its the diagnostic is expected to produce
   public let fixIts: [FixItSpec]
 
-  /// The file and line at which this `NoteSpec` was created, so that assertion failures can be reported at its location.
+  /// The file and line at which this ``NoteSpec`` was created, so that assertion failures can be reported at its location.
   internal let originatorFile: StaticString
   internal let originatorLine: UInt
 
-  /// Creates a new `DiagnosticSpec` that describes a diagnsotic tests are expecting to be generated by a macro expansion.
+  /// Creates a new ``DiagnosticSpec`` that describes a diagnsotic tests are expecting to be generated by a macro expansion.
   ///
   /// - Parameters:
   ///   - id: If not `nil`, the ID, which the diagnostic is expected to have.
@@ -150,8 +150,8 @@ public struct DiagnosticSpec {
   ///   - highlight: If not `nil`, the text the diagnostic is expected to highlight
   ///   - notes: The notes that are expected to be attached to the diagnostic
   ///   - fixIts: The messages of the Fix-Its the diagnostic is expected to produce
-  ///   - originatorFile: The file at which this `NoteSpec` was created, so that assertion failures can be reported at its location.
-  ///   - originatorLine: The line at which this `NoteSpec` was created, so that assertion failures can be reported at its location.
+  ///   - originatorFile: The file at which this ``NoteSpec`` was created, so that assertion failures can be reported at its location.
+  ///   - originatorLine: The line at which this ``NoteSpec`` was created, so that assertion failures can be reported at its location.
   public init(
     id: MessageID? = nil,
     message: String,
diff --git a/Tests/SwiftParserTest/Assertions.swift b/Tests/SwiftParserTest/Assertions.swift
index 682969e5e75..2d5ad2b6ded 100644
--- a/Tests/SwiftParserTest/Assertions.swift
+++ b/Tests/SwiftParserTest/Assertions.swift
@@ -209,7 +209,7 @@ struct NoteSpec {
   /// Asserts that the note has this message.
   let message: String
 
-  /// The file and line at which this `NoteSpec` was created, so that assertion failures can be reported at its location.
+  /// The file and line at which this ``NoteSpec`` was created, so that assertion failures can be reported at its location.
   let file: StaticString
   let line: UInt
 
@@ -244,7 +244,7 @@ struct DiagnosticSpec {
   /// Use the `fixedSource` parameter on `AssertParse` to check that applying the Fix-It yields the expected result.
   let fixIts: [String]
 
-  /// The file and line at which this `DiagnosticSpec` was created, so that assertion failures can be reported at its location.
+  /// The file and line at which this ``DiagnosticSpec`` was created, so that assertion failures can be reported at its location.
   let file: StaticString
   let line: UInt
 
@@ -449,7 +449,7 @@ class MutatedTreePrinter: SyntaxVisitor {
   private var printedSource: [UInt8] = []
 
   /// Prints `tree` by replacing the tokens whose offset is in `mutations` by
-  /// a token that matches the corresponding `TokenSpec`.
+  /// a token that matches the corresponding ``TokenSpec``.
   static func print(tree: Syntax, mutations: [Int: TokenSpec]) -> [UInt8] {
     let printer = MutatedTreePrinter(mutations: mutations)
     printer.walk(tree)
@@ -494,7 +494,7 @@ public struct AssertParseOptions: OptionSet {
 }
 
 /// Same as `assertParse` overload with a `(String) -> S` `parse`,
-/// parsing the resulting `String` as a `SourceFileSyntax`.
+/// parsing the resulting `String` as a ``SourceFileSyntax``.
 func assertParse(
   _ markedSource: String,
   substructure expectedSubstructure: Syntax? = nil,
diff --git a/Tests/SwiftSyntaxTestSupportTest/SyntaxComparisonTests.swift b/Tests/SwiftSyntaxTestSupportTest/SyntaxComparisonTests.swift
index 53298634a95..bbe10ecdae0 100644
--- a/Tests/SwiftSyntaxTestSupportTest/SyntaxComparisonTests.swift
+++ b/Tests/SwiftSyntaxTestSupportTest/SyntaxComparisonTests.swift
@@ -177,7 +177,7 @@ public class SyntaxComparisonTests: XCTestCase {
     XCTAssertEqual(bodyDiff.reason, .additionalNode)
   }
 
-  /// Generates a `FunctionDeclSyntax` with the given `identifier`, `keyword`,
+  /// Generates a ``FunctionDeclSyntax`` with the given `identifier`, `keyword`,
   /// and `body` with some optional leading indentation (which applied only to
   /// the start, not the entire body).
   private func makeFunc(
@@ -211,7 +211,7 @@ public class SyntaxComparisonTests: XCTestCase {
     return fd
   }
 
-  /// Creates a `CodeBlockSyntax` that consists of `statementCount` integer
+  /// Creates a ``CodeBlockSyntax`` that consists of `statementCount` integer
   /// literals with increasing values. Ie. `makeBody(statementCount: 2)`
   /// generates:
   /// ```