diff --git a/crates/oxc_ast/src/generated/ast_builder.rs b/crates/oxc_ast/src/generated/ast_builder.rs
index c8391480b8b6f..8da88143146c2 100644
--- a/crates/oxc_ast/src/generated/ast_builder.rs
+++ b/crates/oxc_ast/src/generated/ast_builder.rs
@@ -22,7 +22,7 @@ pub struct AstBuilder<'a> {
 }
 
 impl<'a> AstBuilder<'a> {
-    /// Build a [`BooleanLiteral`]
+    /// Build a [`BooleanLiteral`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_boolean_literal`] instead.
     ///
@@ -34,7 +34,7 @@ impl<'a> AstBuilder<'a> {
         BooleanLiteral { span, value }
     }
 
-    /// Build a [`BooleanLiteral`] and stores it in the memory arena.
+    /// Build a [`BooleanLiteral`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::boolean_literal`] instead.
     ///
@@ -46,7 +46,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.boolean_literal(span, value), self.allocator)
     }
 
-    /// Build a [`NullLiteral`]
+    /// Build a [`NullLiteral`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_null_literal`] instead.
     ///
@@ -57,7 +57,7 @@ impl<'a> AstBuilder<'a> {
         NullLiteral { span }
     }
 
-    /// Build a [`NullLiteral`] and stores it in the memory arena.
+    /// Build a [`NullLiteral`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::null_literal`] instead.
     ///
@@ -68,7 +68,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.null_literal(span), self.allocator)
     }
 
-    /// Build a [`NumericLiteral`]
+    /// Build a [`NumericLiteral`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_numeric_literal`] instead.
     ///
@@ -91,7 +91,7 @@ impl<'a> AstBuilder<'a> {
         NumericLiteral { span, value, raw: raw.into_in(self.allocator), base }
     }
 
-    /// Build a [`NumericLiteral`] and stores it in the memory arena.
+    /// Build a [`NumericLiteral`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::numeric_literal`] instead.
     ///
@@ -114,7 +114,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.numeric_literal(span, value, raw, base), self.allocator)
     }
 
-    /// Build a [`BigIntLiteral`]
+    /// Build a [`BigIntLiteral`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_big_int_literal`] instead.
     ///
@@ -130,7 +130,7 @@ impl<'a> AstBuilder<'a> {
         BigIntLiteral { span, raw: raw.into_in(self.allocator), base }
     }
 
-    /// Build a [`BigIntLiteral`] and stores it in the memory arena.
+    /// Build a [`BigIntLiteral`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::big_int_literal`] instead.
     ///
@@ -151,7 +151,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.big_int_literal(span, raw, base), self.allocator)
     }
 
-    /// Build a [`RegExpLiteral`]
+    /// Build a [`RegExpLiteral`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_reg_exp_literal`] instead.
     ///
@@ -169,7 +169,7 @@ impl<'a> AstBuilder<'a> {
         RegExpLiteral { span, value, regex }
     }
 
-    /// Build a [`RegExpLiteral`] and stores it in the memory arena.
+    /// Build a [`RegExpLiteral`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::reg_exp_literal`] instead.
     ///
@@ -187,7 +187,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.reg_exp_literal(span, value, regex), self.allocator)
     }
 
-    /// Build a [`StringLiteral`]
+    /// Build a [`StringLiteral`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_string_literal`] instead.
     ///
@@ -202,7 +202,7 @@ impl<'a> AstBuilder<'a> {
         StringLiteral { span, value: value.into_in(self.allocator) }
     }
 
-    /// Build a [`StringLiteral`] and stores it in the memory arena.
+    /// Build a [`StringLiteral`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::string_literal`] instead.
     ///
@@ -217,7 +217,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.string_literal(span, value), self.allocator)
     }
 
-    /// Build a [`Program`]
+    /// Build a [`Program`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_program`] instead.
     ///
@@ -255,7 +255,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`Program`] and stores it in the memory arena.
+    /// Build a [`Program`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::program`] instead.
     ///
@@ -1493,7 +1493,7 @@ impl<'a> AstBuilder<'a> {
         Expression::from(inner)
     }
 
-    /// Build an [`IdentifierName`]
+    /// Build an [`IdentifierName`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_identifier_name`] instead.
     ///
@@ -1508,7 +1508,7 @@ impl<'a> AstBuilder<'a> {
         IdentifierName { span, name: name.into_in(self.allocator) }
     }
 
-    /// Build an [`IdentifierName`] and stores it in the memory arena.
+    /// Build an [`IdentifierName`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::identifier_name`] instead.
     ///
@@ -1523,7 +1523,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.identifier_name(span, name), self.allocator)
     }
 
-    /// Build an [`IdentifierReference`]
+    /// Build an [`IdentifierReference`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_identifier_reference`] instead.
     ///
@@ -1542,7 +1542,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build an [`IdentifierReference`] and stores it in the memory arena.
+    /// Build an [`IdentifierReference`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::identifier_reference`] instead.
     ///
@@ -1561,7 +1561,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.identifier_reference(span, name), self.allocator)
     }
 
-    /// Build a [`BindingIdentifier`]
+    /// Build a [`BindingIdentifier`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_binding_identifier`] instead.
     ///
@@ -1580,7 +1580,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`BindingIdentifier`] and stores it in the memory arena.
+    /// Build a [`BindingIdentifier`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::binding_identifier`] instead.
     ///
@@ -1595,7 +1595,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.binding_identifier(span, name), self.allocator)
     }
 
-    /// Build a [`LabelIdentifier`]
+    /// Build a [`LabelIdentifier`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_label_identifier`] instead.
     ///
@@ -1610,7 +1610,7 @@ impl<'a> AstBuilder<'a> {
         LabelIdentifier { span, name: name.into_in(self.allocator) }
     }
 
-    /// Build a [`LabelIdentifier`] and stores it in the memory arena.
+    /// Build a [`LabelIdentifier`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::label_identifier`] instead.
     ///
@@ -1625,7 +1625,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.label_identifier(span, name), self.allocator)
     }
 
-    /// Build a [`ThisExpression`]
+    /// Build a [`ThisExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_this_expression`] instead.
     ///
@@ -1636,7 +1636,7 @@ impl<'a> AstBuilder<'a> {
         ThisExpression { span }
     }
 
-    /// Build a [`ThisExpression`] and stores it in the memory arena.
+    /// Build a [`ThisExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::this_expression`] instead.
     ///
@@ -1647,7 +1647,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.this_expression(span), self.allocator)
     }
 
-    /// Build an [`ArrayExpression`]
+    /// Build an [`ArrayExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_array_expression`] instead.
     ///
@@ -1665,7 +1665,7 @@ impl<'a> AstBuilder<'a> {
         ArrayExpression { span, elements, trailing_comma }
     }
 
-    /// Build an [`ArrayExpression`] and stores it in the memory arena.
+    /// Build an [`ArrayExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::array_expression`] instead.
     ///
@@ -1738,7 +1738,7 @@ impl<'a> AstBuilder<'a> {
         ArrayExpressionElement::from(inner)
     }
 
-    /// Build an [`Elision`]
+    /// Build an [`Elision`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_elision`] instead.
     ///
@@ -1749,7 +1749,7 @@ impl<'a> AstBuilder<'a> {
         Elision { span }
     }
 
-    /// Build an [`Elision`] and stores it in the memory arena.
+    /// Build an [`Elision`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::elision`] instead.
     ///
@@ -1760,7 +1760,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.elision(span), self.allocator)
     }
 
-    /// Build an [`ObjectExpression`]
+    /// Build an [`ObjectExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_object_expression`] instead.
     ///
@@ -1778,7 +1778,7 @@ impl<'a> AstBuilder<'a> {
         ObjectExpression { span, properties, trailing_comma }
     }
 
-    /// Build an [`ObjectExpression`] and stores it in the memory arena.
+    /// Build an [`ObjectExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::object_expression`] instead.
     ///
@@ -1862,7 +1862,7 @@ impl<'a> AstBuilder<'a> {
         ObjectPropertyKind::SpreadProperty(inner.into_in(self.allocator))
     }
 
-    /// Build an [`ObjectProperty`]
+    /// Build an [`ObjectProperty`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_object_property`] instead.
     ///
@@ -1890,7 +1890,7 @@ impl<'a> AstBuilder<'a> {
         ObjectProperty { span, kind, key, value, init, method, shorthand, computed }
     }
 
-    /// Build an [`ObjectProperty`] and stores it in the memory arena.
+    /// Build an [`ObjectProperty`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::object_property`] instead.
     ///
@@ -1975,7 +1975,7 @@ impl<'a> AstBuilder<'a> {
         PropertyKey::from(inner)
     }
 
-    /// Build a [`TemplateLiteral`]
+    /// Build a [`TemplateLiteral`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_template_literal`] instead.
     ///
@@ -1993,7 +1993,7 @@ impl<'a> AstBuilder<'a> {
         TemplateLiteral { span, quasis, expressions }
     }
 
-    /// Build a [`TemplateLiteral`] and stores it in the memory arena.
+    /// Build a [`TemplateLiteral`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::template_literal`] instead.
     ///
@@ -2011,7 +2011,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.template_literal(span, quasis, expressions), self.allocator)
     }
 
-    /// Build a [`TaggedTemplateExpression`]
+    /// Build a [`TaggedTemplateExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_tagged_template_expression`] instead.
     ///
@@ -2039,7 +2039,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TaggedTemplateExpression`] and stores it in the memory arena.
+    /// Build a [`TaggedTemplateExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::tagged_template_expression`] instead.
     ///
@@ -2065,7 +2065,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TemplateElement`]
+    /// Build a [`TemplateElement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_template_element`] instead.
     ///
@@ -2083,7 +2083,7 @@ impl<'a> AstBuilder<'a> {
         TemplateElement { span, tail, value }
     }
 
-    /// Build a [`TemplateElement`] and stores it in the memory arena.
+    /// Build a [`TemplateElement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::template_element`] instead.
     ///
@@ -2197,7 +2197,7 @@ impl<'a> AstBuilder<'a> {
         MemberExpression::PrivateFieldExpression(inner.into_in(self.allocator))
     }
 
-    /// Build a [`ComputedMemberExpression`]
+    /// Build a [`ComputedMemberExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_computed_member_expression`] instead.
     ///
@@ -2217,7 +2217,7 @@ impl<'a> AstBuilder<'a> {
         ComputedMemberExpression { span, object, expression, optional }
     }
 
-    /// Build a [`ComputedMemberExpression`] and stores it in the memory arena.
+    /// Build a [`ComputedMemberExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::computed_member_expression`] instead.
     ///
@@ -2240,7 +2240,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`StaticMemberExpression`]
+    /// Build a [`StaticMemberExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_static_member_expression`] instead.
     ///
@@ -2260,7 +2260,7 @@ impl<'a> AstBuilder<'a> {
         StaticMemberExpression { span, object, property, optional }
     }
 
-    /// Build a [`StaticMemberExpression`] and stores it in the memory arena.
+    /// Build a [`StaticMemberExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::static_member_expression`] instead.
     ///
@@ -2280,7 +2280,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.static_member_expression(span, object, property, optional), self.allocator)
     }
 
-    /// Build a [`PrivateFieldExpression`]
+    /// Build a [`PrivateFieldExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_private_field_expression`] instead.
     ///
@@ -2300,7 +2300,7 @@ impl<'a> AstBuilder<'a> {
         PrivateFieldExpression { span, object, field, optional }
     }
 
-    /// Build a [`PrivateFieldExpression`] and stores it in the memory arena.
+    /// Build a [`PrivateFieldExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::private_field_expression`] instead.
     ///
@@ -2320,7 +2320,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.private_field_expression(span, object, field, optional), self.allocator)
     }
 
-    /// Build a [`CallExpression`]
+    /// Build a [`CallExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_call_expression`] instead.
     ///
@@ -2351,7 +2351,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`CallExpression`] and stores it in the memory arena.
+    /// Build a [`CallExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::call_expression`] instead.
     ///
@@ -2379,7 +2379,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`NewExpression`]
+    /// Build a [`NewExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_new_expression`] instead.
     ///
@@ -2407,7 +2407,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`NewExpression`] and stores it in the memory arena.
+    /// Build a [`NewExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::new_expression`] instead.
     ///
@@ -2430,7 +2430,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.new_expression(span, callee, arguments, type_parameters), self.allocator)
     }
 
-    /// Build a [`MetaProperty`]
+    /// Build a [`MetaProperty`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_meta_property`] instead.
     ///
@@ -2448,7 +2448,7 @@ impl<'a> AstBuilder<'a> {
         MetaProperty { span, meta, property }
     }
 
-    /// Build a [`MetaProperty`] and stores it in the memory arena.
+    /// Build a [`MetaProperty`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::meta_property`] instead.
     ///
@@ -2466,7 +2466,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.meta_property(span, meta, property), self.allocator)
     }
 
-    /// Build a [`SpreadElement`]
+    /// Build a [`SpreadElement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_spread_element`] instead.
     ///
@@ -2478,7 +2478,7 @@ impl<'a> AstBuilder<'a> {
         SpreadElement { span, argument }
     }
 
-    /// Build a [`SpreadElement`] and stores it in the memory arena.
+    /// Build a [`SpreadElement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::spread_element`] instead.
     ///
@@ -2521,7 +2521,7 @@ impl<'a> AstBuilder<'a> {
         Argument::from(inner)
     }
 
-    /// Build an [`UpdateExpression`]
+    /// Build an [`UpdateExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_update_expression`] instead.
     ///
@@ -2541,7 +2541,7 @@ impl<'a> AstBuilder<'a> {
         UpdateExpression { span, operator, prefix, argument }
     }
 
-    /// Build an [`UpdateExpression`] and stores it in the memory arena.
+    /// Build an [`UpdateExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::update_expression`] instead.
     ///
@@ -2561,7 +2561,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.update_expression(span, operator, prefix, argument), self.allocator)
     }
 
-    /// Build an [`UnaryExpression`]
+    /// Build an [`UnaryExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_unary_expression`] instead.
     ///
@@ -2579,7 +2579,7 @@ impl<'a> AstBuilder<'a> {
         UnaryExpression { span, operator, argument }
     }
 
-    /// Build an [`UnaryExpression`] and stores it in the memory arena.
+    /// Build an [`UnaryExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::unary_expression`] instead.
     ///
@@ -2597,7 +2597,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.unary_expression(span, operator, argument), self.allocator)
     }
 
-    /// Build a [`BinaryExpression`]
+    /// Build a [`BinaryExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_binary_expression`] instead.
     ///
@@ -2617,7 +2617,7 @@ impl<'a> AstBuilder<'a> {
         BinaryExpression { span, left, operator, right }
     }
 
-    /// Build a [`BinaryExpression`] and stores it in the memory arena.
+    /// Build a [`BinaryExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::binary_expression`] instead.
     ///
@@ -2637,7 +2637,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.binary_expression(span, left, operator, right), self.allocator)
     }
 
-    /// Build a [`PrivateInExpression`]
+    /// Build a [`PrivateInExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_private_in_expression`] instead.
     ///
@@ -2657,7 +2657,7 @@ impl<'a> AstBuilder<'a> {
         PrivateInExpression { span, left, operator, right }
     }
 
-    /// Build a [`PrivateInExpression`] and stores it in the memory arena.
+    /// Build a [`PrivateInExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::private_in_expression`] instead.
     ///
@@ -2677,7 +2677,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.private_in_expression(span, left, operator, right), self.allocator)
     }
 
-    /// Build a [`LogicalExpression`]
+    /// Build a [`LogicalExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_logical_expression`] instead.
     ///
@@ -2697,7 +2697,7 @@ impl<'a> AstBuilder<'a> {
         LogicalExpression { span, left, operator, right }
     }
 
-    /// Build a [`LogicalExpression`] and stores it in the memory arena.
+    /// Build a [`LogicalExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::logical_expression`] instead.
     ///
@@ -2717,7 +2717,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.logical_expression(span, left, operator, right), self.allocator)
     }
 
-    /// Build a [`ConditionalExpression`]
+    /// Build a [`ConditionalExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_conditional_expression`] instead.
     ///
@@ -2737,7 +2737,7 @@ impl<'a> AstBuilder<'a> {
         ConditionalExpression { span, test, consequent, alternate }
     }
 
-    /// Build a [`ConditionalExpression`] and stores it in the memory arena.
+    /// Build a [`ConditionalExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::conditional_expression`] instead.
     ///
@@ -2757,7 +2757,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.conditional_expression(span, test, consequent, alternate), self.allocator)
     }
 
-    /// Build an [`AssignmentExpression`]
+    /// Build an [`AssignmentExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_assignment_expression`] instead.
     ///
@@ -2777,7 +2777,7 @@ impl<'a> AstBuilder<'a> {
         AssignmentExpression { span, operator, left, right }
     }
 
-    /// Build an [`AssignmentExpression`] and stores it in the memory arena.
+    /// Build an [`AssignmentExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::assignment_expression`] instead.
     ///
@@ -3093,7 +3093,7 @@ impl<'a> AstBuilder<'a> {
         AssignmentTargetPattern::ObjectAssignmentTarget(inner.into_in(self.allocator))
     }
 
-    /// Build an [`ArrayAssignmentTarget`]
+    /// Build an [`ArrayAssignmentTarget`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_array_assignment_target`] instead.
     ///
@@ -3113,7 +3113,7 @@ impl<'a> AstBuilder<'a> {
         ArrayAssignmentTarget { span, elements, rest, trailing_comma }
     }
 
-    /// Build an [`ArrayAssignmentTarget`] and stores it in the memory arena.
+    /// Build an [`ArrayAssignmentTarget`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::array_assignment_target`] instead.
     ///
@@ -3136,7 +3136,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build an [`ObjectAssignmentTarget`]
+    /// Build an [`ObjectAssignmentTarget`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_object_assignment_target`] instead.
     ///
@@ -3154,7 +3154,7 @@ impl<'a> AstBuilder<'a> {
         ObjectAssignmentTarget { span, properties, rest }
     }
 
-    /// Build an [`ObjectAssignmentTarget`] and stores it in the memory arena.
+    /// Build an [`ObjectAssignmentTarget`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::object_assignment_target`] instead.
     ///
@@ -3172,7 +3172,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.object_assignment_target(span, properties, rest), self.allocator)
     }
 
-    /// Build an [`AssignmentTargetRest`]
+    /// Build an [`AssignmentTargetRest`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_assignment_target_rest`] instead.
     ///
@@ -3188,7 +3188,7 @@ impl<'a> AstBuilder<'a> {
         AssignmentTargetRest { span, target }
     }
 
-    /// Build an [`AssignmentTargetRest`] and stores it in the memory arena.
+    /// Build an [`AssignmentTargetRest`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::assignment_target_rest`] instead.
     ///
@@ -3245,7 +3245,7 @@ impl<'a> AstBuilder<'a> {
         AssignmentTargetMaybeDefault::from(inner)
     }
 
-    /// Build an [`AssignmentTargetWithDefault`]
+    /// Build an [`AssignmentTargetWithDefault`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_assignment_target_with_default`] instead.
     ///
@@ -3263,7 +3263,7 @@ impl<'a> AstBuilder<'a> {
         AssignmentTargetWithDefault { span, binding, init }
     }
 
-    /// Build an [`AssignmentTargetWithDefault`] and stores it in the memory arena.
+    /// Build an [`AssignmentTargetWithDefault`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::assignment_target_with_default`] instead.
     ///
@@ -3345,7 +3345,7 @@ impl<'a> AstBuilder<'a> {
         AssignmentTargetProperty::AssignmentTargetPropertyProperty(inner.into_in(self.allocator))
     }
 
-    /// Build an [`AssignmentTargetPropertyIdentifier`]
+    /// Build an [`AssignmentTargetPropertyIdentifier`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_assignment_target_property_identifier`] instead.
     ///
@@ -3363,7 +3363,7 @@ impl<'a> AstBuilder<'a> {
         AssignmentTargetPropertyIdentifier { span, binding, init }
     }
 
-    /// Build an [`AssignmentTargetPropertyIdentifier`] and stores it in the memory arena.
+    /// Build an [`AssignmentTargetPropertyIdentifier`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::assignment_target_property_identifier`] instead.
     ///
@@ -3381,7 +3381,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.assignment_target_property_identifier(span, binding, init), self.allocator)
     }
 
-    /// Build an [`AssignmentTargetPropertyProperty`]
+    /// Build an [`AssignmentTargetPropertyProperty`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_assignment_target_property_property`] instead.
     ///
@@ -3399,7 +3399,7 @@ impl<'a> AstBuilder<'a> {
         AssignmentTargetPropertyProperty { span, name, binding }
     }
 
-    /// Build an [`AssignmentTargetPropertyProperty`] and stores it in the memory arena.
+    /// Build an [`AssignmentTargetPropertyProperty`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::assignment_target_property_property`] instead.
     ///
@@ -3417,7 +3417,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.assignment_target_property_property(span, name, binding), self.allocator)
     }
 
-    /// Build a [`SequenceExpression`]
+    /// Build a [`SequenceExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_sequence_expression`] instead.
     ///
@@ -3433,7 +3433,7 @@ impl<'a> AstBuilder<'a> {
         SequenceExpression { span, expressions }
     }
 
-    /// Build a [`SequenceExpression`] and stores it in the memory arena.
+    /// Build a [`SequenceExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::sequence_expression`] instead.
     ///
@@ -3449,7 +3449,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.sequence_expression(span, expressions), self.allocator)
     }
 
-    /// Build a [`Super`]
+    /// Build a [`Super`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_super_`] instead.
     ///
@@ -3460,7 +3460,7 @@ impl<'a> AstBuilder<'a> {
         Super { span }
     }
 
-    /// Build a [`Super`] and stores it in the memory arena.
+    /// Build a [`Super`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::super_`] instead.
     ///
@@ -3471,7 +3471,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.super_(span), self.allocator)
     }
 
-    /// Build an [`AwaitExpression`]
+    /// Build an [`AwaitExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_await_expression`] instead.
     ///
@@ -3483,7 +3483,7 @@ impl<'a> AstBuilder<'a> {
         AwaitExpression { span, argument }
     }
 
-    /// Build an [`AwaitExpression`] and stores it in the memory arena.
+    /// Build an [`AwaitExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::await_expression`] instead.
     ///
@@ -3499,7 +3499,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.await_expression(span, argument), self.allocator)
     }
 
-    /// Build a [`ChainExpression`]
+    /// Build a [`ChainExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_chain_expression`] instead.
     ///
@@ -3511,7 +3511,7 @@ impl<'a> AstBuilder<'a> {
         ChainExpression { span, expression }
     }
 
-    /// Build a [`ChainExpression`] and stores it in the memory arena.
+    /// Build a [`ChainExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::chain_expression`] instead.
     ///
@@ -3573,7 +3573,7 @@ impl<'a> AstBuilder<'a> {
         ChainElement::from(inner)
     }
 
-    /// Build a [`ParenthesizedExpression`]
+    /// Build a [`ParenthesizedExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_parenthesized_expression`] instead.
     ///
@@ -3589,7 +3589,7 @@ impl<'a> AstBuilder<'a> {
         ParenthesizedExpression { span, expression }
     }
 
-    /// Build a [`ParenthesizedExpression`] and stores it in the memory arena.
+    /// Build a [`ParenthesizedExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::parenthesized_expression`] instead.
     ///
@@ -4078,7 +4078,7 @@ impl<'a> AstBuilder<'a> {
         Statement::from(inner)
     }
 
-    /// Build a [`Directive`]
+    /// Build a [`Directive`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_directive`] instead.
     ///
@@ -4099,7 +4099,7 @@ impl<'a> AstBuilder<'a> {
         Directive { span, expression, directive: directive.into_in(self.allocator) }
     }
 
-    /// Build a [`Directive`] and stores it in the memory arena.
+    /// Build a [`Directive`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::directive`] instead.
     ///
@@ -4120,7 +4120,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.directive(span, expression, directive), self.allocator)
     }
 
-    /// Build a [`Hashbang`]
+    /// Build a [`Hashbang`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_hashbang`] instead.
     ///
@@ -4135,7 +4135,7 @@ impl<'a> AstBuilder<'a> {
         Hashbang { span, value: value.into_in(self.allocator) }
     }
 
-    /// Build a [`Hashbang`] and stores it in the memory arena.
+    /// Build a [`Hashbang`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::hashbang`] instead.
     ///
@@ -4150,7 +4150,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.hashbang(span, value), self.allocator)
     }
 
-    /// Build a [`BlockStatement`]
+    /// Build a [`BlockStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_block_statement`] instead.
     ///
@@ -4162,7 +4162,7 @@ impl<'a> AstBuilder<'a> {
         BlockStatement { span, body, scope_id: Default::default() }
     }
 
-    /// Build a [`BlockStatement`] and stores it in the memory arena.
+    /// Build a [`BlockStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::block_statement`] instead.
     ///
@@ -4518,7 +4518,7 @@ impl<'a> AstBuilder<'a> {
         Declaration::TSImportEqualsDeclaration(inner.into_in(self.allocator))
     }
 
-    /// Build a [`VariableDeclaration`]
+    /// Build a [`VariableDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_variable_declaration`] instead.
     ///
@@ -4538,7 +4538,7 @@ impl<'a> AstBuilder<'a> {
         VariableDeclaration { span, kind, declarations, declare }
     }
 
-    /// Build a [`VariableDeclaration`] and stores it in the memory arena.
+    /// Build a [`VariableDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::variable_declaration`] instead.
     ///
@@ -4558,7 +4558,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.variable_declaration(span, kind, declarations, declare), self.allocator)
     }
 
-    /// Build a [`VariableDeclarator`]
+    /// Build a [`VariableDeclarator`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_variable_declarator`] instead.
     ///
@@ -4580,7 +4580,7 @@ impl<'a> AstBuilder<'a> {
         VariableDeclarator { span, kind, id, init, definite }
     }
 
-    /// Build a [`VariableDeclarator`] and stores it in the memory arena.
+    /// Build a [`VariableDeclarator`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::variable_declarator`] instead.
     ///
@@ -4602,7 +4602,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.variable_declarator(span, kind, id, init, definite), self.allocator)
     }
 
-    /// Build an [`EmptyStatement`]
+    /// Build an [`EmptyStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_empty_statement`] instead.
     ///
@@ -4613,7 +4613,7 @@ impl<'a> AstBuilder<'a> {
         EmptyStatement { span }
     }
 
-    /// Build an [`EmptyStatement`] and stores it in the memory arena.
+    /// Build an [`EmptyStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::empty_statement`] instead.
     ///
@@ -4624,7 +4624,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.empty_statement(span), self.allocator)
     }
 
-    /// Build an [`ExpressionStatement`]
+    /// Build an [`ExpressionStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_expression_statement`] instead.
     ///
@@ -4640,7 +4640,7 @@ impl<'a> AstBuilder<'a> {
         ExpressionStatement { span, expression }
     }
 
-    /// Build an [`ExpressionStatement`] and stores it in the memory arena.
+    /// Build an [`ExpressionStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::expression_statement`] instead.
     ///
@@ -4656,7 +4656,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.expression_statement(span, expression), self.allocator)
     }
 
-    /// Build an [`IfStatement`]
+    /// Build an [`IfStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_if_statement`] instead.
     ///
@@ -4676,7 +4676,7 @@ impl<'a> AstBuilder<'a> {
         IfStatement { span, test, consequent, alternate }
     }
 
-    /// Build an [`IfStatement`] and stores it in the memory arena.
+    /// Build an [`IfStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::if_statement`] instead.
     ///
@@ -4696,7 +4696,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.if_statement(span, test, consequent, alternate), self.allocator)
     }
 
-    /// Build a [`DoWhileStatement`]
+    /// Build a [`DoWhileStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_do_while_statement`] instead.
     ///
@@ -4714,7 +4714,7 @@ impl<'a> AstBuilder<'a> {
         DoWhileStatement { span, body, test }
     }
 
-    /// Build a [`DoWhileStatement`] and stores it in the memory arena.
+    /// Build a [`DoWhileStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::do_while_statement`] instead.
     ///
@@ -4732,7 +4732,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.do_while_statement(span, body, test), self.allocator)
     }
 
-    /// Build a [`WhileStatement`]
+    /// Build a [`WhileStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_while_statement`] instead.
     ///
@@ -4750,7 +4750,7 @@ impl<'a> AstBuilder<'a> {
         WhileStatement { span, test, body }
     }
 
-    /// Build a [`WhileStatement`] and stores it in the memory arena.
+    /// Build a [`WhileStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::while_statement`] instead.
     ///
@@ -4768,7 +4768,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.while_statement(span, test, body), self.allocator)
     }
 
-    /// Build a [`ForStatement`]
+    /// Build a [`ForStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_for_statement`] instead.
     ///
@@ -4790,7 +4790,7 @@ impl<'a> AstBuilder<'a> {
         ForStatement { span, init, test, update, body, scope_id: Default::default() }
     }
 
-    /// Build a [`ForStatement`] and stores it in the memory arena.
+    /// Build a [`ForStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::for_statement`] instead.
     ///
@@ -4852,7 +4852,7 @@ impl<'a> AstBuilder<'a> {
         ForStatementInit::from(inner)
     }
 
-    /// Build a [`ForInStatement`]
+    /// Build a [`ForInStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_for_in_statement`] instead.
     ///
@@ -4872,7 +4872,7 @@ impl<'a> AstBuilder<'a> {
         ForInStatement { span, left, right, body, scope_id: Default::default() }
     }
 
-    /// Build a [`ForInStatement`] and stores it in the memory arena.
+    /// Build a [`ForInStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::for_in_statement`] instead.
     ///
@@ -4935,7 +4935,7 @@ impl<'a> AstBuilder<'a> {
         ForStatementLeft::from(inner)
     }
 
-    /// Build a [`ForOfStatement`]
+    /// Build a [`ForOfStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_for_of_statement`] instead.
     ///
@@ -4957,7 +4957,7 @@ impl<'a> AstBuilder<'a> {
         ForOfStatement { span, r#await, left, right, body, scope_id: Default::default() }
     }
 
-    /// Build a [`ForOfStatement`] and stores it in the memory arena.
+    /// Build a [`ForOfStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::for_of_statement`] instead.
     ///
@@ -4979,7 +4979,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.for_of_statement(span, r#await, left, right, body), self.allocator)
     }
 
-    /// Build a [`ContinueStatement`]
+    /// Build a [`ContinueStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_continue_statement`] instead.
     ///
@@ -4995,7 +4995,7 @@ impl<'a> AstBuilder<'a> {
         ContinueStatement { span, label }
     }
 
-    /// Build a [`ContinueStatement`] and stores it in the memory arena.
+    /// Build a [`ContinueStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::continue_statement`] instead.
     ///
@@ -5011,7 +5011,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.continue_statement(span, label), self.allocator)
     }
 
-    /// Build a [`BreakStatement`]
+    /// Build a [`BreakStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_break_statement`] instead.
     ///
@@ -5027,7 +5027,7 @@ impl<'a> AstBuilder<'a> {
         BreakStatement { span, label }
     }
 
-    /// Build a [`BreakStatement`] and stores it in the memory arena.
+    /// Build a [`BreakStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::break_statement`] instead.
     ///
@@ -5043,7 +5043,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.break_statement(span, label), self.allocator)
     }
 
-    /// Build a [`ReturnStatement`]
+    /// Build a [`ReturnStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_return_statement`] instead.
     ///
@@ -5059,7 +5059,7 @@ impl<'a> AstBuilder<'a> {
         ReturnStatement { span, argument }
     }
 
-    /// Build a [`ReturnStatement`] and stores it in the memory arena.
+    /// Build a [`ReturnStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::return_statement`] instead.
     ///
@@ -5075,7 +5075,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.return_statement(span, argument), self.allocator)
     }
 
-    /// Build a [`WithStatement`]
+    /// Build a [`WithStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_with_statement`] instead.
     ///
@@ -5093,7 +5093,7 @@ impl<'a> AstBuilder<'a> {
         WithStatement { span, object, body }
     }
 
-    /// Build a [`WithStatement`] and stores it in the memory arena.
+    /// Build a [`WithStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::with_statement`] instead.
     ///
@@ -5111,7 +5111,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.with_statement(span, object, body), self.allocator)
     }
 
-    /// Build a [`SwitchStatement`]
+    /// Build a [`SwitchStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_switch_statement`] instead.
     ///
@@ -5129,7 +5129,7 @@ impl<'a> AstBuilder<'a> {
         SwitchStatement { span, discriminant, cases, scope_id: Default::default() }
     }
 
-    /// Build a [`SwitchStatement`] and stores it in the memory arena.
+    /// Build a [`SwitchStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::switch_statement`] instead.
     ///
@@ -5147,7 +5147,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.switch_statement(span, discriminant, cases), self.allocator)
     }
 
-    /// Build a [`SwitchCase`]
+    /// Build a [`SwitchCase`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_switch_case`] instead.
     ///
@@ -5165,7 +5165,7 @@ impl<'a> AstBuilder<'a> {
         SwitchCase { span, test, consequent }
     }
 
-    /// Build a [`SwitchCase`] and stores it in the memory arena.
+    /// Build a [`SwitchCase`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::switch_case`] instead.
     ///
@@ -5183,7 +5183,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.switch_case(span, test, consequent), self.allocator)
     }
 
-    /// Build a [`LabeledStatement`]
+    /// Build a [`LabeledStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_labeled_statement`] instead.
     ///
@@ -5201,7 +5201,7 @@ impl<'a> AstBuilder<'a> {
         LabeledStatement { span, label, body }
     }
 
-    /// Build a [`LabeledStatement`] and stores it in the memory arena.
+    /// Build a [`LabeledStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::labeled_statement`] instead.
     ///
@@ -5219,7 +5219,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.labeled_statement(span, label, body), self.allocator)
     }
 
-    /// Build a [`ThrowStatement`]
+    /// Build a [`ThrowStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_throw_statement`] instead.
     ///
@@ -5231,7 +5231,7 @@ impl<'a> AstBuilder<'a> {
         ThrowStatement { span, argument }
     }
 
-    /// Build a [`ThrowStatement`] and stores it in the memory arena.
+    /// Build a [`ThrowStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::throw_statement`] instead.
     ///
@@ -5247,7 +5247,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.throw_statement(span, argument), self.allocator)
     }
 
-    /// Build a [`TryStatement`]
+    /// Build a [`TryStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_try_statement`] instead.
     ///
@@ -5277,7 +5277,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TryStatement`] and stores it in the memory arena.
+    /// Build a [`TryStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::try_statement`] instead.
     ///
@@ -5302,7 +5302,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.try_statement(span, block, handler, finalizer), self.allocator)
     }
 
-    /// Build a [`CatchClause`]
+    /// Build a [`CatchClause`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_catch_clause`] instead.
     ///
@@ -5328,7 +5328,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`CatchClause`] and stores it in the memory arena.
+    /// Build a [`CatchClause`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::catch_clause`] instead.
     ///
@@ -5349,7 +5349,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.catch_clause(span, param, body), self.allocator)
     }
 
-    /// Build a [`CatchParameter`]
+    /// Build a [`CatchParameter`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_catch_parameter`] instead.
     ///
@@ -5361,7 +5361,7 @@ impl<'a> AstBuilder<'a> {
         CatchParameter { span, pattern }
     }
 
-    /// Build a [`CatchParameter`] and stores it in the memory arena.
+    /// Build a [`CatchParameter`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::catch_parameter`] instead.
     ///
@@ -5377,7 +5377,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.catch_parameter(span, pattern), self.allocator)
     }
 
-    /// Build a [`DebuggerStatement`]
+    /// Build a [`DebuggerStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_debugger_statement`] instead.
     ///
@@ -5388,7 +5388,7 @@ impl<'a> AstBuilder<'a> {
         DebuggerStatement { span }
     }
 
-    /// Build a [`DebuggerStatement`] and stores it in the memory arena.
+    /// Build a [`DebuggerStatement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::debugger_statement`] instead.
     ///
@@ -5399,7 +5399,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.debugger_statement(span), self.allocator)
     }
 
-    /// Build a [`BindingPattern`]
+    /// Build a [`BindingPattern`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_binding_pattern`] instead.
     ///
@@ -5420,7 +5420,7 @@ impl<'a> AstBuilder<'a> {
         BindingPattern { kind, type_annotation: type_annotation.into_in(self.allocator), optional }
     }
 
-    /// Build a [`BindingPattern`] and stores it in the memory arena.
+    /// Build a [`BindingPattern`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::binding_pattern`] instead.
     ///
@@ -5558,7 +5558,7 @@ impl<'a> AstBuilder<'a> {
         BindingPatternKind::AssignmentPattern(inner.into_in(self.allocator))
     }
 
-    /// Build an [`AssignmentPattern`]
+    /// Build an [`AssignmentPattern`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_assignment_pattern`] instead.
     ///
@@ -5576,7 +5576,7 @@ impl<'a> AstBuilder<'a> {
         AssignmentPattern { span, left, right }
     }
 
-    /// Build an [`AssignmentPattern`] and stores it in the memory arena.
+    /// Build an [`AssignmentPattern`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::assignment_pattern`] instead.
     ///
@@ -5594,7 +5594,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.assignment_pattern(span, left, right), self.allocator)
     }
 
-    /// Build an [`ObjectPattern`]
+    /// Build an [`ObjectPattern`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_object_pattern`] instead.
     ///
@@ -5615,7 +5615,7 @@ impl<'a> AstBuilder<'a> {
         ObjectPattern { span, properties, rest: rest.into_in(self.allocator) }
     }
 
-    /// Build an [`ObjectPattern`] and stores it in the memory arena.
+    /// Build an [`ObjectPattern`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::object_pattern`] instead.
     ///
@@ -5636,7 +5636,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.object_pattern(span, properties, rest), self.allocator)
     }
 
-    /// Build a [`BindingProperty`]
+    /// Build a [`BindingProperty`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_binding_property`] instead.
     ///
@@ -5658,7 +5658,7 @@ impl<'a> AstBuilder<'a> {
         BindingProperty { span, key, value, shorthand, computed }
     }
 
-    /// Build a [`BindingProperty`] and stores it in the memory arena.
+    /// Build a [`BindingProperty`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::binding_property`] instead.
     ///
@@ -5680,7 +5680,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.binding_property(span, key, value, shorthand, computed), self.allocator)
     }
 
-    /// Build an [`ArrayPattern`]
+    /// Build an [`ArrayPattern`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_array_pattern`] instead.
     ///
@@ -5701,7 +5701,7 @@ impl<'a> AstBuilder<'a> {
         ArrayPattern { span, elements, rest: rest.into_in(self.allocator) }
     }
 
-    /// Build an [`ArrayPattern`] and stores it in the memory arena.
+    /// Build an [`ArrayPattern`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::array_pattern`] instead.
     ///
@@ -5722,7 +5722,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.array_pattern(span, elements, rest), self.allocator)
     }
 
-    /// Build a [`BindingRestElement`]
+    /// Build a [`BindingRestElement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_binding_rest_element`] instead.
     ///
@@ -5738,7 +5738,7 @@ impl<'a> AstBuilder<'a> {
         BindingRestElement { span, argument }
     }
 
-    /// Build a [`BindingRestElement`] and stores it in the memory arena.
+    /// Build a [`BindingRestElement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::binding_rest_element`] instead.
     ///
@@ -5754,7 +5754,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.binding_rest_element(span, argument), self.allocator)
     }
 
-    /// Build a [`Function`]
+    /// Build a [`Function`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_function`] instead.
     ///
@@ -5808,7 +5808,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`Function`] and stores it in the memory arena.
+    /// Build a [`Function`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::function`] instead.
     ///
@@ -5864,7 +5864,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`FormalParameters`]
+    /// Build a [`FormalParameters`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_formal_parameters`] instead.
     ///
@@ -5887,7 +5887,7 @@ impl<'a> AstBuilder<'a> {
         FormalParameters { span, kind, items, rest: rest.into_in(self.allocator) }
     }
 
-    /// Build a [`FormalParameters`] and stores it in the memory arena.
+    /// Build a [`FormalParameters`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::formal_parameters`] instead.
     ///
@@ -5910,7 +5910,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.formal_parameters(span, kind, items, rest), self.allocator)
     }
 
-    /// Build a [`FormalParameter`]
+    /// Build a [`FormalParameter`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_formal_parameter`] instead.
     ///
@@ -5934,7 +5934,7 @@ impl<'a> AstBuilder<'a> {
         FormalParameter { span, decorators, pattern, accessibility, readonly, r#override }
     }
 
-    /// Build a [`FormalParameter`] and stores it in the memory arena.
+    /// Build a [`FormalParameter`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::formal_parameter`] instead.
     ///
@@ -5961,7 +5961,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`FunctionBody`]
+    /// Build a [`FunctionBody`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_function_body`] instead.
     ///
@@ -5979,7 +5979,7 @@ impl<'a> AstBuilder<'a> {
         FunctionBody { span, directives, statements }
     }
 
-    /// Build a [`FunctionBody`] and stores it in the memory arena.
+    /// Build a [`FunctionBody`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::function_body`] instead.
     ///
@@ -5997,7 +5997,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.function_body(span, directives, statements), self.allocator)
     }
 
-    /// Build an [`ArrowFunctionExpression`]
+    /// Build an [`ArrowFunctionExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_arrow_function_expression`] instead.
     ///
@@ -6038,7 +6038,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build an [`ArrowFunctionExpression`] and stores it in the memory arena.
+    /// Build an [`ArrowFunctionExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::arrow_function_expression`] instead.
     ///
@@ -6081,7 +6081,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`YieldExpression`]
+    /// Build a [`YieldExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_yield_expression`] instead.
     ///
@@ -6099,7 +6099,7 @@ impl<'a> AstBuilder<'a> {
         YieldExpression { span, delegate, argument }
     }
 
-    /// Build a [`YieldExpression`] and stores it in the memory arena.
+    /// Build a [`YieldExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::yield_expression`] instead.
     ///
@@ -6117,7 +6117,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.yield_expression(span, delegate, argument), self.allocator)
     }
 
-    /// Build a [`Class`]
+    /// Build a [`Class`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_class`] instead.
     ///
@@ -6169,7 +6169,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`Class`] and stores it in the memory arena.
+    /// Build a [`Class`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::class`] instead.
     ///
@@ -6223,7 +6223,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`ClassBody`]
+    /// Build a [`ClassBody`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_class_body`] instead.
     ///
@@ -6235,7 +6235,7 @@ impl<'a> AstBuilder<'a> {
         ClassBody { span, body }
     }
 
-    /// Build a [`ClassBody`] and stores it in the memory arena.
+    /// Build a [`ClassBody`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::class_body`] instead.
     ///
@@ -6493,7 +6493,7 @@ impl<'a> AstBuilder<'a> {
         ClassElement::TSIndexSignature(inner.into_in(self.allocator))
     }
 
-    /// Build a [`MethodDefinition`]
+    /// Build a [`MethodDefinition`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_method_definition`] instead.
     ///
@@ -6542,7 +6542,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`MethodDefinition`] and stores it in the memory arena.
+    /// Build a [`MethodDefinition`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::method_definition`] instead.
     ///
@@ -6594,7 +6594,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`PropertyDefinition`]
+    /// Build a [`PropertyDefinition`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_property_definition`] instead.
     ///
@@ -6652,7 +6652,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`PropertyDefinition`] and stores it in the memory arena.
+    /// Build a [`PropertyDefinition`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::property_definition`] instead.
     ///
@@ -6713,7 +6713,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`PrivateIdentifier`]
+    /// Build a [`PrivateIdentifier`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_private_identifier`] instead.
     ///
@@ -6728,7 +6728,7 @@ impl<'a> AstBuilder<'a> {
         PrivateIdentifier { span, name: name.into_in(self.allocator) }
     }
 
-    /// Build a [`PrivateIdentifier`] and stores it in the memory arena.
+    /// Build a [`PrivateIdentifier`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::private_identifier`] instead.
     ///
@@ -6743,7 +6743,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.private_identifier(span, name), self.allocator)
     }
 
-    /// Build a [`StaticBlock`]
+    /// Build a [`StaticBlock`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_static_block`] instead.
     ///
@@ -6755,7 +6755,7 @@ impl<'a> AstBuilder<'a> {
         StaticBlock { span, body, scope_id: Default::default() }
     }
 
-    /// Build a [`StaticBlock`] and stores it in the memory arena.
+    /// Build a [`StaticBlock`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::static_block`] instead.
     ///
@@ -6991,7 +6991,7 @@ impl<'a> AstBuilder<'a> {
         ModuleDeclaration::TSNamespaceExportDeclaration(inner.into_in(self.allocator))
     }
 
-    /// Build an [`AccessorProperty`]
+    /// Build an [`AccessorProperty`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_accessor_property`] instead.
     ///
@@ -7037,7 +7037,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build an [`AccessorProperty`] and stores it in the memory arena.
+    /// Build an [`AccessorProperty`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::accessor_property`] instead.
     ///
@@ -7086,7 +7086,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build an [`ImportExpression`]
+    /// Build an [`ImportExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_import_expression`] instead.
     ///
@@ -7104,7 +7104,7 @@ impl<'a> AstBuilder<'a> {
         ImportExpression { span, source, arguments }
     }
 
-    /// Build an [`ImportExpression`] and stores it in the memory arena.
+    /// Build an [`ImportExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::import_expression`] instead.
     ///
@@ -7122,7 +7122,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.import_expression(span, source, arguments), self.allocator)
     }
 
-    /// Build an [`ImportDeclaration`]
+    /// Build an [`ImportDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_import_declaration`] instead.
     ///
@@ -7153,7 +7153,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build an [`ImportDeclaration`] and stores it in the memory arena.
+    /// Build an [`ImportDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::import_declaration`] instead.
     ///
@@ -7278,7 +7278,7 @@ impl<'a> AstBuilder<'a> {
         ImportDeclarationSpecifier::ImportNamespaceSpecifier(inner.into_in(self.allocator))
     }
 
-    /// Build an [`ImportSpecifier`]
+    /// Build an [`ImportSpecifier`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_import_specifier`] instead.
     ///
@@ -7298,7 +7298,7 @@ impl<'a> AstBuilder<'a> {
         ImportSpecifier { span, imported, local, import_kind }
     }
 
-    /// Build an [`ImportSpecifier`] and stores it in the memory arena.
+    /// Build an [`ImportSpecifier`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::import_specifier`] instead.
     ///
@@ -7318,7 +7318,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.import_specifier(span, imported, local, import_kind), self.allocator)
     }
 
-    /// Build an [`ImportDefaultSpecifier`]
+    /// Build an [`ImportDefaultSpecifier`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_import_default_specifier`] instead.
     ///
@@ -7334,7 +7334,7 @@ impl<'a> AstBuilder<'a> {
         ImportDefaultSpecifier { span, local }
     }
 
-    /// Build an [`ImportDefaultSpecifier`] and stores it in the memory arena.
+    /// Build an [`ImportDefaultSpecifier`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::import_default_specifier`] instead.
     ///
@@ -7350,7 +7350,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.import_default_specifier(span, local), self.allocator)
     }
 
-    /// Build an [`ImportNamespaceSpecifier`]
+    /// Build an [`ImportNamespaceSpecifier`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_import_namespace_specifier`] instead.
     ///
@@ -7366,7 +7366,7 @@ impl<'a> AstBuilder<'a> {
         ImportNamespaceSpecifier { span, local }
     }
 
-    /// Build an [`ImportNamespaceSpecifier`] and stores it in the memory arena.
+    /// Build an [`ImportNamespaceSpecifier`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::import_namespace_specifier`] instead.
     ///
@@ -7382,7 +7382,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.import_namespace_specifier(span, local), self.allocator)
     }
 
-    /// Build a [`WithClause`]
+    /// Build a [`WithClause`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_with_clause`] instead.
     ///
@@ -7400,7 +7400,7 @@ impl<'a> AstBuilder<'a> {
         WithClause { span, attributes_keyword, with_entries }
     }
 
-    /// Build a [`WithClause`] and stores it in the memory arena.
+    /// Build a [`WithClause`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::with_clause`] instead.
     ///
@@ -7418,7 +7418,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.with_clause(span, attributes_keyword, with_entries), self.allocator)
     }
 
-    /// Build an [`ImportAttribute`]
+    /// Build an [`ImportAttribute`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_import_attribute`] instead.
     ///
@@ -7436,7 +7436,7 @@ impl<'a> AstBuilder<'a> {
         ImportAttribute { span, key, value }
     }
 
-    /// Build an [`ImportAttribute`] and stores it in the memory arena.
+    /// Build an [`ImportAttribute`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::import_attribute`] instead.
     ///
@@ -7506,7 +7506,7 @@ impl<'a> AstBuilder<'a> {
         ImportAttributeKey::StringLiteral(inner.into_in(self.allocator))
     }
 
-    /// Build an [`ExportNamedDeclaration`]
+    /// Build an [`ExportNamedDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_export_named_declaration`] instead.
     ///
@@ -7540,7 +7540,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build an [`ExportNamedDeclaration`] and stores it in the memory arena.
+    /// Build an [`ExportNamedDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::export_named_declaration`] instead.
     ///
@@ -7577,7 +7577,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build an [`ExportDefaultDeclaration`]
+    /// Build an [`ExportDefaultDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_export_default_declaration`] instead.
     ///
@@ -7595,7 +7595,7 @@ impl<'a> AstBuilder<'a> {
         ExportDefaultDeclaration { span, declaration, exported }
     }
 
-    /// Build an [`ExportDefaultDeclaration`] and stores it in the memory arena.
+    /// Build an [`ExportDefaultDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::export_default_declaration`] instead.
     ///
@@ -7613,7 +7613,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.export_default_declaration(span, declaration, exported), self.allocator)
     }
 
-    /// Build an [`ExportAllDeclaration`]
+    /// Build an [`ExportAllDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_export_all_declaration`] instead.
     ///
@@ -7644,7 +7644,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build an [`ExportAllDeclaration`] and stores it in the memory arena.
+    /// Build an [`ExportAllDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::export_all_declaration`] instead.
     ///
@@ -7672,7 +7672,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build an [`ExportSpecifier`]
+    /// Build an [`ExportSpecifier`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_export_specifier`] instead.
     ///
@@ -7692,7 +7692,7 @@ impl<'a> AstBuilder<'a> {
         ExportSpecifier { span, local, exported, export_kind }
     }
 
-    /// Build an [`ExportSpecifier`] and stores it in the memory arena.
+    /// Build an [`ExportSpecifier`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::export_specifier`] instead.
     ///
@@ -7961,7 +7961,7 @@ impl<'a> AstBuilder<'a> {
         ModuleExportName::StringLiteral(inner.into_in(self.allocator))
     }
 
-    /// Build a [`TSThisParameter`]
+    /// Build a [`TSThisParameter`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_this_parameter`] instead.
     ///
@@ -7986,7 +7986,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSThisParameter`] and stores it in the memory arena.
+    /// Build a [`TSThisParameter`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_this_parameter`] instead.
     ///
@@ -8007,7 +8007,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_this_parameter(span, this_span, type_annotation), self.allocator)
     }
 
-    /// Build a [`TSEnumDeclaration`]
+    /// Build a [`TSEnumDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_enum_declaration`] instead.
     ///
@@ -8029,7 +8029,7 @@ impl<'a> AstBuilder<'a> {
         TSEnumDeclaration { span, id, members, r#const, declare, scope_id: Default::default() }
     }
 
-    /// Build a [`TSEnumDeclaration`] and stores it in the memory arena.
+    /// Build a [`TSEnumDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_enum_declaration`] instead.
     ///
@@ -8051,7 +8051,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_enum_declaration(span, id, members, r#const, declare), self.allocator)
     }
 
-    /// Build a [`TSEnumMember`]
+    /// Build a [`TSEnumMember`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_enum_member`] instead.
     ///
@@ -8069,7 +8069,7 @@ impl<'a> AstBuilder<'a> {
         TSEnumMember { span, id, initializer }
     }
 
-    /// Build a [`TSEnumMember`] and stores it in the memory arena.
+    /// Build a [`TSEnumMember`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_enum_member`] instead.
     ///
@@ -8206,7 +8206,7 @@ impl<'a> AstBuilder<'a> {
         TSEnumMemberName::from(inner)
     }
 
-    /// Build a [`TSTypeAnnotation`]
+    /// Build a [`TSTypeAnnotation`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_annotation`] instead.
     ///
@@ -8222,7 +8222,7 @@ impl<'a> AstBuilder<'a> {
         TSTypeAnnotation { span, type_annotation }
     }
 
-    /// Build a [`TSTypeAnnotation`] and stores it in the memory arena.
+    /// Build a [`TSTypeAnnotation`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_annotation`] instead.
     ///
@@ -8238,7 +8238,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_type_annotation(span, type_annotation), self.allocator)
     }
 
-    /// Build a [`TSLiteralType`]
+    /// Build a [`TSLiteralType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_literal_type`] instead.
     ///
@@ -8250,7 +8250,7 @@ impl<'a> AstBuilder<'a> {
         TSLiteralType { span, literal }
     }
 
-    /// Build a [`TSLiteralType`] and stores it in the memory arena.
+    /// Build a [`TSLiteralType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_literal_type`] instead.
     ///
@@ -9473,7 +9473,7 @@ impl<'a> AstBuilder<'a> {
         TSType::JSDocUnknownType(inner.into_in(self.allocator))
     }
 
-    /// Build a [`TSConditionalType`]
+    /// Build a [`TSConditionalType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_conditional_type`] instead.
     ///
@@ -9502,7 +9502,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSConditionalType`] and stores it in the memory arena.
+    /// Build a [`TSConditionalType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_conditional_type`] instead.
     ///
@@ -9527,7 +9527,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSUnionType`]
+    /// Build a [`TSUnionType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_union_type`] instead.
     ///
@@ -9539,7 +9539,7 @@ impl<'a> AstBuilder<'a> {
         TSUnionType { span, types }
     }
 
-    /// Build a [`TSUnionType`] and stores it in the memory arena.
+    /// Build a [`TSUnionType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_union_type`] instead.
     ///
@@ -9555,7 +9555,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_union_type(span, types), self.allocator)
     }
 
-    /// Build a [`TSIntersectionType`]
+    /// Build a [`TSIntersectionType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_intersection_type`] instead.
     ///
@@ -9571,7 +9571,7 @@ impl<'a> AstBuilder<'a> {
         TSIntersectionType { span, types }
     }
 
-    /// Build a [`TSIntersectionType`] and stores it in the memory arena.
+    /// Build a [`TSIntersectionType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_intersection_type`] instead.
     ///
@@ -9587,7 +9587,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_intersection_type(span, types), self.allocator)
     }
 
-    /// Build a [`TSParenthesizedType`]
+    /// Build a [`TSParenthesizedType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_parenthesized_type`] instead.
     ///
@@ -9603,7 +9603,7 @@ impl<'a> AstBuilder<'a> {
         TSParenthesizedType { span, type_annotation }
     }
 
-    /// Build a [`TSParenthesizedType`] and stores it in the memory arena.
+    /// Build a [`TSParenthesizedType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_parenthesized_type`] instead.
     ///
@@ -9619,7 +9619,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_parenthesized_type(span, type_annotation), self.allocator)
     }
 
-    /// Build a [`TSTypeOperator`]
+    /// Build a [`TSTypeOperator`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_operator`] instead.
     ///
@@ -9637,7 +9637,7 @@ impl<'a> AstBuilder<'a> {
         TSTypeOperator { span, operator, type_annotation }
     }
 
-    /// Build a [`TSTypeOperator`] and stores it in the memory arena.
+    /// Build a [`TSTypeOperator`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_operator`] instead.
     ///
@@ -9655,7 +9655,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_type_operator(span, operator, type_annotation), self.allocator)
     }
 
-    /// Build a [`TSArrayType`]
+    /// Build a [`TSArrayType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_array_type`] instead.
     ///
@@ -9667,7 +9667,7 @@ impl<'a> AstBuilder<'a> {
         TSArrayType { span, element_type }
     }
 
-    /// Build a [`TSArrayType`] and stores it in the memory arena.
+    /// Build a [`TSArrayType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_array_type`] instead.
     ///
@@ -9683,7 +9683,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_array_type(span, element_type), self.allocator)
     }
 
-    /// Build a [`TSIndexedAccessType`]
+    /// Build a [`TSIndexedAccessType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_indexed_access_type`] instead.
     ///
@@ -9701,7 +9701,7 @@ impl<'a> AstBuilder<'a> {
         TSIndexedAccessType { span, object_type, index_type }
     }
 
-    /// Build a [`TSIndexedAccessType`] and stores it in the memory arena.
+    /// Build a [`TSIndexedAccessType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_indexed_access_type`] instead.
     ///
@@ -9719,7 +9719,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_indexed_access_type(span, object_type, index_type), self.allocator)
     }
 
-    /// Build a [`TSTupleType`]
+    /// Build a [`TSTupleType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_tuple_type`] instead.
     ///
@@ -9735,7 +9735,7 @@ impl<'a> AstBuilder<'a> {
         TSTupleType { span, element_types }
     }
 
-    /// Build a [`TSTupleType`] and stores it in the memory arena.
+    /// Build a [`TSTupleType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_tuple_type`] instead.
     ///
@@ -9751,7 +9751,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_tuple_type(span, element_types), self.allocator)
     }
 
-    /// Build a [`TSNamedTupleMember`]
+    /// Build a [`TSNamedTupleMember`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_named_tuple_member`] instead.
     ///
@@ -9771,7 +9771,7 @@ impl<'a> AstBuilder<'a> {
         TSNamedTupleMember { span, element_type, label, optional }
     }
 
-    /// Build a [`TSNamedTupleMember`] and stores it in the memory arena.
+    /// Build a [`TSNamedTupleMember`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_named_tuple_member`] instead.
     ///
@@ -9791,7 +9791,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_named_tuple_member(span, element_type, label, optional), self.allocator)
     }
 
-    /// Build a [`TSOptionalType`]
+    /// Build a [`TSOptionalType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_optional_type`] instead.
     ///
@@ -9803,7 +9803,7 @@ impl<'a> AstBuilder<'a> {
         TSOptionalType { span, type_annotation }
     }
 
-    /// Build a [`TSOptionalType`] and stores it in the memory arena.
+    /// Build a [`TSOptionalType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_optional_type`] instead.
     ///
@@ -9819,7 +9819,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_optional_type(span, type_annotation), self.allocator)
     }
 
-    /// Build a [`TSRestType`]
+    /// Build a [`TSRestType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_rest_type`] instead.
     ///
@@ -9831,7 +9831,7 @@ impl<'a> AstBuilder<'a> {
         TSRestType { span, type_annotation }
     }
 
-    /// Build a [`TSRestType`] and stores it in the memory arena.
+    /// Build a [`TSRestType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_rest_type`] instead.
     ///
@@ -9903,7 +9903,7 @@ impl<'a> AstBuilder<'a> {
         TSTupleElement::from(inner)
     }
 
-    /// Build a [`TSAnyKeyword`]
+    /// Build a [`TSAnyKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_any_keyword`] instead.
     ///
@@ -9914,7 +9914,7 @@ impl<'a> AstBuilder<'a> {
         TSAnyKeyword { span }
     }
 
-    /// Build a [`TSAnyKeyword`] and stores it in the memory arena.
+    /// Build a [`TSAnyKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_any_keyword`] instead.
     ///
@@ -9925,7 +9925,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_any_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSStringKeyword`]
+    /// Build a [`TSStringKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_string_keyword`] instead.
     ///
@@ -9936,7 +9936,7 @@ impl<'a> AstBuilder<'a> {
         TSStringKeyword { span }
     }
 
-    /// Build a [`TSStringKeyword`] and stores it in the memory arena.
+    /// Build a [`TSStringKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_string_keyword`] instead.
     ///
@@ -9947,7 +9947,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_string_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSBooleanKeyword`]
+    /// Build a [`TSBooleanKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_boolean_keyword`] instead.
     ///
@@ -9958,7 +9958,7 @@ impl<'a> AstBuilder<'a> {
         TSBooleanKeyword { span }
     }
 
-    /// Build a [`TSBooleanKeyword`] and stores it in the memory arena.
+    /// Build a [`TSBooleanKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_boolean_keyword`] instead.
     ///
@@ -9969,7 +9969,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_boolean_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSNumberKeyword`]
+    /// Build a [`TSNumberKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_number_keyword`] instead.
     ///
@@ -9980,7 +9980,7 @@ impl<'a> AstBuilder<'a> {
         TSNumberKeyword { span }
     }
 
-    /// Build a [`TSNumberKeyword`] and stores it in the memory arena.
+    /// Build a [`TSNumberKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_number_keyword`] instead.
     ///
@@ -9991,7 +9991,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_number_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSNeverKeyword`]
+    /// Build a [`TSNeverKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_never_keyword`] instead.
     ///
@@ -10002,7 +10002,7 @@ impl<'a> AstBuilder<'a> {
         TSNeverKeyword { span }
     }
 
-    /// Build a [`TSNeverKeyword`] and stores it in the memory arena.
+    /// Build a [`TSNeverKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_never_keyword`] instead.
     ///
@@ -10013,7 +10013,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_never_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSIntrinsicKeyword`]
+    /// Build a [`TSIntrinsicKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_intrinsic_keyword`] instead.
     ///
@@ -10024,7 +10024,7 @@ impl<'a> AstBuilder<'a> {
         TSIntrinsicKeyword { span }
     }
 
-    /// Build a [`TSIntrinsicKeyword`] and stores it in the memory arena.
+    /// Build a [`TSIntrinsicKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_intrinsic_keyword`] instead.
     ///
@@ -10035,7 +10035,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_intrinsic_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSUnknownKeyword`]
+    /// Build a [`TSUnknownKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_unknown_keyword`] instead.
     ///
@@ -10046,7 +10046,7 @@ impl<'a> AstBuilder<'a> {
         TSUnknownKeyword { span }
     }
 
-    /// Build a [`TSUnknownKeyword`] and stores it in the memory arena.
+    /// Build a [`TSUnknownKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_unknown_keyword`] instead.
     ///
@@ -10057,7 +10057,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_unknown_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSNullKeyword`]
+    /// Build a [`TSNullKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_null_keyword`] instead.
     ///
@@ -10068,7 +10068,7 @@ impl<'a> AstBuilder<'a> {
         TSNullKeyword { span }
     }
 
-    /// Build a [`TSNullKeyword`] and stores it in the memory arena.
+    /// Build a [`TSNullKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_null_keyword`] instead.
     ///
@@ -10079,7 +10079,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_null_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSUndefinedKeyword`]
+    /// Build a [`TSUndefinedKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_undefined_keyword`] instead.
     ///
@@ -10090,7 +10090,7 @@ impl<'a> AstBuilder<'a> {
         TSUndefinedKeyword { span }
     }
 
-    /// Build a [`TSUndefinedKeyword`] and stores it in the memory arena.
+    /// Build a [`TSUndefinedKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_undefined_keyword`] instead.
     ///
@@ -10101,7 +10101,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_undefined_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSVoidKeyword`]
+    /// Build a [`TSVoidKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_void_keyword`] instead.
     ///
@@ -10112,7 +10112,7 @@ impl<'a> AstBuilder<'a> {
         TSVoidKeyword { span }
     }
 
-    /// Build a [`TSVoidKeyword`] and stores it in the memory arena.
+    /// Build a [`TSVoidKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_void_keyword`] instead.
     ///
@@ -10123,7 +10123,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_void_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSSymbolKeyword`]
+    /// Build a [`TSSymbolKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_symbol_keyword`] instead.
     ///
@@ -10134,7 +10134,7 @@ impl<'a> AstBuilder<'a> {
         TSSymbolKeyword { span }
     }
 
-    /// Build a [`TSSymbolKeyword`] and stores it in the memory arena.
+    /// Build a [`TSSymbolKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_symbol_keyword`] instead.
     ///
@@ -10145,7 +10145,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_symbol_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSThisType`]
+    /// Build a [`TSThisType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_this_type`] instead.
     ///
@@ -10156,7 +10156,7 @@ impl<'a> AstBuilder<'a> {
         TSThisType { span }
     }
 
-    /// Build a [`TSThisType`] and stores it in the memory arena.
+    /// Build a [`TSThisType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_this_type`] instead.
     ///
@@ -10167,7 +10167,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_this_type(span), self.allocator)
     }
 
-    /// Build a [`TSObjectKeyword`]
+    /// Build a [`TSObjectKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_object_keyword`] instead.
     ///
@@ -10178,7 +10178,7 @@ impl<'a> AstBuilder<'a> {
         TSObjectKeyword { span }
     }
 
-    /// Build a [`TSObjectKeyword`] and stores it in the memory arena.
+    /// Build a [`TSObjectKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_object_keyword`] instead.
     ///
@@ -10189,7 +10189,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_object_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSBigIntKeyword`]
+    /// Build a [`TSBigIntKeyword`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_big_int_keyword`] instead.
     ///
@@ -10200,7 +10200,7 @@ impl<'a> AstBuilder<'a> {
         TSBigIntKeyword { span }
     }
 
-    /// Build a [`TSBigIntKeyword`] and stores it in the memory arena.
+    /// Build a [`TSBigIntKeyword`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_big_int_keyword`] instead.
     ///
@@ -10211,7 +10211,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_big_int_keyword(span), self.allocator)
     }
 
-    /// Build a [`TSTypeReference`]
+    /// Build a [`TSTypeReference`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_reference`] instead.
     ///
@@ -10236,7 +10236,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSTypeReference`] and stores it in the memory arena.
+    /// Build a [`TSTypeReference`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_reference`] instead.
     ///
@@ -10308,7 +10308,7 @@ impl<'a> AstBuilder<'a> {
         TSTypeName::QualifiedName(inner.into_in(self.allocator))
     }
 
-    /// Build a [`TSQualifiedName`]
+    /// Build a [`TSQualifiedName`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_qualified_name`] instead.
     ///
@@ -10326,7 +10326,7 @@ impl<'a> AstBuilder<'a> {
         TSQualifiedName { span, left, right }
     }
 
-    /// Build a [`TSQualifiedName`] and stores it in the memory arena.
+    /// Build a [`TSQualifiedName`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_qualified_name`] instead.
     ///
@@ -10344,7 +10344,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_qualified_name(span, left, right), self.allocator)
     }
 
-    /// Build a [`TSTypeParameterInstantiation`]
+    /// Build a [`TSTypeParameterInstantiation`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_parameter_instantiation`] instead.
     ///
@@ -10360,7 +10360,7 @@ impl<'a> AstBuilder<'a> {
         TSTypeParameterInstantiation { span, params }
     }
 
-    /// Build a [`TSTypeParameterInstantiation`] and stores it in the memory arena.
+    /// Build a [`TSTypeParameterInstantiation`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_parameter_instantiation`] instead.
     ///
@@ -10376,7 +10376,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_type_parameter_instantiation(span, params), self.allocator)
     }
 
-    /// Build a [`TSTypeParameter`]
+    /// Build a [`TSTypeParameter`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_parameter`] instead.
     ///
@@ -10402,7 +10402,7 @@ impl<'a> AstBuilder<'a> {
         TSTypeParameter { span, name, constraint, default, r#in, out, r#const }
     }
 
-    /// Build a [`TSTypeParameter`] and stores it in the memory arena.
+    /// Build a [`TSTypeParameter`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_parameter`] instead.
     ///
@@ -10431,7 +10431,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSTypeParameterDeclaration`]
+    /// Build a [`TSTypeParameterDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_parameter_declaration`] instead.
     ///
@@ -10447,7 +10447,7 @@ impl<'a> AstBuilder<'a> {
         TSTypeParameterDeclaration { span, params }
     }
 
-    /// Build a [`TSTypeParameterDeclaration`] and stores it in the memory arena.
+    /// Build a [`TSTypeParameterDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_parameter_declaration`] instead.
     ///
@@ -10463,7 +10463,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_type_parameter_declaration(span, params), self.allocator)
     }
 
-    /// Build a [`TSTypeAliasDeclaration`]
+    /// Build a [`TSTypeAliasDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_alias_declaration`] instead.
     ///
@@ -10495,7 +10495,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSTypeAliasDeclaration`] and stores it in the memory arena.
+    /// Build a [`TSTypeAliasDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_alias_declaration`] instead.
     ///
@@ -10523,7 +10523,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSClassImplements`]
+    /// Build a [`TSClassImplements`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_class_implements`] instead.
     ///
@@ -10548,7 +10548,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSClassImplements`] and stores it in the memory arena.
+    /// Build a [`TSClassImplements`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_class_implements`] instead.
     ///
@@ -10569,7 +10569,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_class_implements(span, expression, type_parameters), self.allocator)
     }
 
-    /// Build a [`TSInterfaceDeclaration`]
+    /// Build a [`TSInterfaceDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_interface_declaration`] instead.
     ///
@@ -10605,7 +10605,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSInterfaceDeclaration`] and stores it in the memory arena.
+    /// Build a [`TSInterfaceDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_interface_declaration`] instead.
     ///
@@ -10636,7 +10636,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSInterfaceBody`]
+    /// Build a [`TSInterfaceBody`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_interface_body`] instead.
     ///
@@ -10652,7 +10652,7 @@ impl<'a> AstBuilder<'a> {
         TSInterfaceBody { span, body }
     }
 
-    /// Build a [`TSInterfaceBody`] and stores it in the memory arena.
+    /// Build a [`TSInterfaceBody`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_interface_body`] instead.
     ///
@@ -10668,7 +10668,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_interface_body(span, body), self.allocator)
     }
 
-    /// Build a [`TSPropertySignature`]
+    /// Build a [`TSPropertySignature`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_property_signature`] instead.
     ///
@@ -10702,7 +10702,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSPropertySignature`] and stores it in the memory arena.
+    /// Build a [`TSPropertySignature`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_property_signature`] instead.
     ///
@@ -10948,7 +10948,7 @@ impl<'a> AstBuilder<'a> {
         TSSignature::TSMethodSignature(inner.into_in(self.allocator))
     }
 
-    /// Build a [`TSIndexSignature`]
+    /// Build a [`TSIndexSignature`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_index_signature`] instead.
     ///
@@ -10976,7 +10976,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSIndexSignature`] and stores it in the memory arena.
+    /// Build a [`TSIndexSignature`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_index_signature`] instead.
     ///
@@ -11002,7 +11002,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSCallSignatureDeclaration`]
+    /// Build a [`TSCallSignatureDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_call_signature_declaration`] instead.
     ///
@@ -11035,7 +11035,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSCallSignatureDeclaration`] and stores it in the memory arena.
+    /// Build a [`TSCallSignatureDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_call_signature_declaration`] instead.
     ///
@@ -11071,7 +11071,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSMethodSignature`]
+    /// Build a [`TSMethodSignature`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_method_signature`] instead.
     ///
@@ -11118,7 +11118,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSMethodSignature`] and stores it in the memory arena.
+    /// Build a [`TSMethodSignature`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_method_signature`] instead.
     ///
@@ -11167,7 +11167,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSConstructSignatureDeclaration`]
+    /// Build a [`TSConstructSignatureDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_construct_signature_declaration`] instead.
     ///
@@ -11198,7 +11198,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSConstructSignatureDeclaration`] and stores it in the memory arena.
+    /// Build a [`TSConstructSignatureDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_construct_signature_declaration`] instead.
     ///
@@ -11226,7 +11226,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSIndexSignatureName`]
+    /// Build a [`TSIndexSignatureName`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_index_signature_name`] instead.
     ///
@@ -11252,7 +11252,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSIndexSignatureName`] and stores it in the memory arena.
+    /// Build a [`TSIndexSignatureName`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_index_signature_name`] instead.
     ///
@@ -11274,7 +11274,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_index_signature_name(span, name, type_annotation), self.allocator)
     }
 
-    /// Build a [`TSInterfaceHeritage`]
+    /// Build a [`TSInterfaceHeritage`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_interface_heritage`] instead.
     ///
@@ -11299,7 +11299,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSInterfaceHeritage`] and stores it in the memory arena.
+    /// Build a [`TSInterfaceHeritage`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_interface_heritage`] instead.
     ///
@@ -11320,7 +11320,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_interface_heritage(span, expression, type_parameters), self.allocator)
     }
 
-    /// Build a [`TSTypePredicate`]
+    /// Build a [`TSTypePredicate`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_predicate`] instead.
     ///
@@ -11348,7 +11348,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSTypePredicate`] and stores it in the memory arena.
+    /// Build a [`TSTypePredicate`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_predicate`] instead.
     ///
@@ -11420,7 +11420,7 @@ impl<'a> AstBuilder<'a> {
         TSTypePredicateName::This(inner.into_in(self.allocator))
     }
 
-    /// Build a [`TSModuleDeclaration`]
+    /// Build a [`TSModuleDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_module_declaration`] instead.
     ///
@@ -11442,7 +11442,7 @@ impl<'a> AstBuilder<'a> {
         TSModuleDeclaration { span, id, body, kind, declare, scope_id: Default::default() }
     }
 
-    /// Build a [`TSModuleDeclaration`] and stores it in the memory arena.
+    /// Build a [`TSModuleDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_module_declaration`] instead.
     ///
@@ -11590,7 +11590,7 @@ impl<'a> AstBuilder<'a> {
         TSModuleDeclarationBody::TSModuleBlock(inner.into_in(self.allocator))
     }
 
-    /// Build a [`TSModuleBlock`]
+    /// Build a [`TSModuleBlock`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_module_block`] instead.
     ///
@@ -11608,7 +11608,7 @@ impl<'a> AstBuilder<'a> {
         TSModuleBlock { span, directives, body }
     }
 
-    /// Build a [`TSModuleBlock`] and stores it in the memory arena.
+    /// Build a [`TSModuleBlock`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_module_block`] instead.
     ///
@@ -11626,7 +11626,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_module_block(span, directives, body), self.allocator)
     }
 
-    /// Build a [`TSTypeLiteral`]
+    /// Build a [`TSTypeLiteral`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_literal`] instead.
     ///
@@ -11642,7 +11642,7 @@ impl<'a> AstBuilder<'a> {
         TSTypeLiteral { span, members }
     }
 
-    /// Build a [`TSTypeLiteral`] and stores it in the memory arena.
+    /// Build a [`TSTypeLiteral`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_literal`] instead.
     ///
@@ -11658,7 +11658,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_type_literal(span, members), self.allocator)
     }
 
-    /// Build a [`TSInferType`]
+    /// Build a [`TSInferType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_infer_type`] instead.
     ///
@@ -11673,7 +11673,7 @@ impl<'a> AstBuilder<'a> {
         TSInferType { span, type_parameter: type_parameter.into_in(self.allocator) }
     }
 
-    /// Build a [`TSInferType`] and stores it in the memory arena.
+    /// Build a [`TSInferType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_infer_type`] instead.
     ///
@@ -11688,7 +11688,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_infer_type(span, type_parameter), self.allocator)
     }
 
-    /// Build a [`TSTypeQuery`]
+    /// Build a [`TSTypeQuery`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_query`] instead.
     ///
@@ -11709,7 +11709,7 @@ impl<'a> AstBuilder<'a> {
         TSTypeQuery { span, expr_name, type_parameters: type_parameters.into_in(self.allocator) }
     }
 
-    /// Build a [`TSTypeQuery`] and stores it in the memory arena.
+    /// Build a [`TSTypeQuery`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_query`] instead.
     ///
@@ -11783,7 +11783,7 @@ impl<'a> AstBuilder<'a> {
         TSTypeQueryExprName::from(inner)
     }
 
-    /// Build a [`TSImportType`]
+    /// Build a [`TSImportType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_import_type`] instead.
     ///
@@ -11818,7 +11818,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSImportType`] and stores it in the memory arena.
+    /// Build a [`TSImportType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_import_type`] instead.
     ///
@@ -11856,7 +11856,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSImportAttributes`]
+    /// Build a [`TSImportAttributes`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_import_attributes`] instead.
     ///
@@ -11874,7 +11874,7 @@ impl<'a> AstBuilder<'a> {
         TSImportAttributes { span, attributes_keyword, elements }
     }
 
-    /// Build a [`TSImportAttributes`] and stores it in the memory arena.
+    /// Build a [`TSImportAttributes`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_import_attributes`] instead.
     ///
@@ -11892,7 +11892,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_import_attributes(span, attributes_keyword, elements), self.allocator)
     }
 
-    /// Build a [`TSImportAttribute`]
+    /// Build a [`TSImportAttribute`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_import_attribute`] instead.
     ///
@@ -11910,7 +11910,7 @@ impl<'a> AstBuilder<'a> {
         TSImportAttribute { span, name, value }
     }
 
-    /// Build a [`TSImportAttribute`] and stores it in the memory arena.
+    /// Build a [`TSImportAttribute`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_import_attribute`] instead.
     ///
@@ -11986,7 +11986,7 @@ impl<'a> AstBuilder<'a> {
         TSImportAttributeName::StringLiteral(inner.into_in(self.allocator))
     }
 
-    /// Build a [`TSFunctionType`]
+    /// Build a [`TSFunctionType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_function_type`] instead.
     ///
@@ -12020,7 +12020,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSFunctionType`] and stores it in the memory arena.
+    /// Build a [`TSFunctionType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_function_type`] instead.
     ///
@@ -12051,7 +12051,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSConstructorType`]
+    /// Build a [`TSConstructorType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_constructor_type`] instead.
     ///
@@ -12084,7 +12084,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSConstructorType`] and stores it in the memory arena.
+    /// Build a [`TSConstructorType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_constructor_type`] instead.
     ///
@@ -12114,7 +12114,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSMappedType`]
+    /// Build a [`TSMappedType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_mapped_type`] instead.
     ///
@@ -12149,7 +12149,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSMappedType`] and stores it in the memory arena.
+    /// Build a [`TSMappedType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_mapped_type`] instead.
     ///
@@ -12186,7 +12186,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`TSTemplateLiteralType`]
+    /// Build a [`TSTemplateLiteralType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_template_literal_type`] instead.
     ///
@@ -12204,7 +12204,7 @@ impl<'a> AstBuilder<'a> {
         TSTemplateLiteralType { span, quasis, types }
     }
 
-    /// Build a [`TSTemplateLiteralType`] and stores it in the memory arena.
+    /// Build a [`TSTemplateLiteralType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_template_literal_type`] instead.
     ///
@@ -12222,7 +12222,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_template_literal_type(span, quasis, types), self.allocator)
     }
 
-    /// Build a [`TSAsExpression`]
+    /// Build a [`TSAsExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_as_expression`] instead.
     ///
@@ -12240,7 +12240,7 @@ impl<'a> AstBuilder<'a> {
         TSAsExpression { span, expression, type_annotation }
     }
 
-    /// Build a [`TSAsExpression`] and stores it in the memory arena.
+    /// Build a [`TSAsExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_as_expression`] instead.
     ///
@@ -12258,7 +12258,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_as_expression(span, expression, type_annotation), self.allocator)
     }
 
-    /// Build a [`TSSatisfiesExpression`]
+    /// Build a [`TSSatisfiesExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_satisfies_expression`] instead.
     ///
@@ -12276,7 +12276,7 @@ impl<'a> AstBuilder<'a> {
         TSSatisfiesExpression { span, expression, type_annotation }
     }
 
-    /// Build a [`TSSatisfiesExpression`] and stores it in the memory arena.
+    /// Build a [`TSSatisfiesExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_satisfies_expression`] instead.
     ///
@@ -12294,7 +12294,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_satisfies_expression(span, expression, type_annotation), self.allocator)
     }
 
-    /// Build a [`TSTypeAssertion`]
+    /// Build a [`TSTypeAssertion`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_type_assertion`] instead.
     ///
@@ -12312,7 +12312,7 @@ impl<'a> AstBuilder<'a> {
         TSTypeAssertion { span, expression, type_annotation }
     }
 
-    /// Build a [`TSTypeAssertion`] and stores it in the memory arena.
+    /// Build a [`TSTypeAssertion`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_type_assertion`] instead.
     ///
@@ -12330,7 +12330,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_type_assertion(span, expression, type_annotation), self.allocator)
     }
 
-    /// Build a [`TSImportEqualsDeclaration`]
+    /// Build a [`TSImportEqualsDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_import_equals_declaration`] instead.
     ///
@@ -12350,7 +12350,7 @@ impl<'a> AstBuilder<'a> {
         TSImportEqualsDeclaration { span, id, module_reference, import_kind }
     }
 
-    /// Build a [`TSImportEqualsDeclaration`] and stores it in the memory arena.
+    /// Build a [`TSImportEqualsDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_import_equals_declaration`] instead.
     ///
@@ -12409,7 +12409,7 @@ impl<'a> AstBuilder<'a> {
         TSModuleReference::from(inner)
     }
 
-    /// Build a [`TSExternalModuleReference`]
+    /// Build a [`TSExternalModuleReference`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_external_module_reference`] instead.
     ///
@@ -12425,7 +12425,7 @@ impl<'a> AstBuilder<'a> {
         TSExternalModuleReference { span, expression }
     }
 
-    /// Build a [`TSExternalModuleReference`] and stores it in the memory arena.
+    /// Build a [`TSExternalModuleReference`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_external_module_reference`] instead.
     ///
@@ -12441,7 +12441,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_external_module_reference(span, expression), self.allocator)
     }
 
-    /// Build a [`TSNonNullExpression`]
+    /// Build a [`TSNonNullExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_non_null_expression`] instead.
     ///
@@ -12457,7 +12457,7 @@ impl<'a> AstBuilder<'a> {
         TSNonNullExpression { span, expression }
     }
 
-    /// Build a [`TSNonNullExpression`] and stores it in the memory arena.
+    /// Build a [`TSNonNullExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_non_null_expression`] instead.
     ///
@@ -12473,7 +12473,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_non_null_expression(span, expression), self.allocator)
     }
 
-    /// Build a [`Decorator`]
+    /// Build a [`Decorator`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_decorator`] instead.
     ///
@@ -12485,7 +12485,7 @@ impl<'a> AstBuilder<'a> {
         Decorator { span, expression }
     }
 
-    /// Build a [`Decorator`] and stores it in the memory arena.
+    /// Build a [`Decorator`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::decorator`] instead.
     ///
@@ -12497,7 +12497,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.decorator(span, expression), self.allocator)
     }
 
-    /// Build a [`TSExportAssignment`]
+    /// Build a [`TSExportAssignment`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_export_assignment`] instead.
     ///
@@ -12513,7 +12513,7 @@ impl<'a> AstBuilder<'a> {
         TSExportAssignment { span, expression }
     }
 
-    /// Build a [`TSExportAssignment`] and stores it in the memory arena.
+    /// Build a [`TSExportAssignment`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_export_assignment`] instead.
     ///
@@ -12529,7 +12529,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_export_assignment(span, expression), self.allocator)
     }
 
-    /// Build a [`TSNamespaceExportDeclaration`]
+    /// Build a [`TSNamespaceExportDeclaration`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_namespace_export_declaration`] instead.
     ///
@@ -12545,7 +12545,7 @@ impl<'a> AstBuilder<'a> {
         TSNamespaceExportDeclaration { span, id }
     }
 
-    /// Build a [`TSNamespaceExportDeclaration`] and stores it in the memory arena.
+    /// Build a [`TSNamespaceExportDeclaration`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_namespace_export_declaration`] instead.
     ///
@@ -12561,7 +12561,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.ts_namespace_export_declaration(span, id), self.allocator)
     }
 
-    /// Build a [`TSInstantiationExpression`]
+    /// Build a [`TSInstantiationExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_ts_instantiation_expression`] instead.
     ///
@@ -12586,7 +12586,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`TSInstantiationExpression`] and stores it in the memory arena.
+    /// Build a [`TSInstantiationExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::ts_instantiation_expression`] instead.
     ///
@@ -12610,7 +12610,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`JSDocNullableType`]
+    /// Build a [`JSDocNullableType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_js_doc_nullable_type`] instead.
     ///
@@ -12628,7 +12628,7 @@ impl<'a> AstBuilder<'a> {
         JSDocNullableType { span, type_annotation, postfix }
     }
 
-    /// Build a [`JSDocNullableType`] and stores it in the memory arena.
+    /// Build a [`JSDocNullableType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::js_doc_nullable_type`] instead.
     ///
@@ -12646,7 +12646,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.js_doc_nullable_type(span, type_annotation, postfix), self.allocator)
     }
 
-    /// Build a [`JSDocNonNullableType`]
+    /// Build a [`JSDocNonNullableType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_js_doc_non_nullable_type`] instead.
     ///
@@ -12664,7 +12664,7 @@ impl<'a> AstBuilder<'a> {
         JSDocNonNullableType { span, type_annotation, postfix }
     }
 
-    /// Build a [`JSDocNonNullableType`] and stores it in the memory arena.
+    /// Build a [`JSDocNonNullableType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::js_doc_non_nullable_type`] instead.
     ///
@@ -12682,7 +12682,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.js_doc_non_nullable_type(span, type_annotation, postfix), self.allocator)
     }
 
-    /// Build a [`JSDocUnknownType`]
+    /// Build a [`JSDocUnknownType`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_js_doc_unknown_type`] instead.
     ///
@@ -12693,7 +12693,7 @@ impl<'a> AstBuilder<'a> {
         JSDocUnknownType { span }
     }
 
-    /// Build a [`JSDocUnknownType`] and stores it in the memory arena.
+    /// Build a [`JSDocUnknownType`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::js_doc_unknown_type`] instead.
     ///
@@ -12704,7 +12704,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.js_doc_unknown_type(span), self.allocator)
     }
 
-    /// Build a [`JSXElement`]
+    /// Build a [`JSXElement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_element`] instead.
     ///
@@ -12733,7 +12733,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`JSXElement`] and stores it in the memory arena.
+    /// Build a [`JSXElement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_element`] instead.
     ///
@@ -12760,7 +12760,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`JSXOpeningElement`]
+    /// Build a [`JSXOpeningElement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_opening_element`] instead.
     ///
@@ -12791,7 +12791,7 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Build a [`JSXOpeningElement`] and stores it in the memory arena.
+    /// Build a [`JSXOpeningElement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_opening_element`] instead.
     ///
@@ -12819,7 +12819,7 @@ impl<'a> AstBuilder<'a> {
         )
     }
 
-    /// Build a [`JSXClosingElement`]
+    /// Build a [`JSXClosingElement`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_closing_element`] instead.
     ///
@@ -12835,7 +12835,7 @@ impl<'a> AstBuilder<'a> {
         JSXClosingElement { span, name }
     }
 
-    /// Build a [`JSXClosingElement`] and stores it in the memory arena.
+    /// Build a [`JSXClosingElement`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_closing_element`] instead.
     ///
@@ -12851,7 +12851,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.jsx_closing_element(span, name), self.allocator)
     }
 
-    /// Build a [`JSXFragment`]
+    /// Build a [`JSXFragment`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_fragment`] instead.
     ///
@@ -12871,7 +12871,7 @@ impl<'a> AstBuilder<'a> {
         JSXFragment { span, opening_fragment, closing_fragment, children }
     }
 
-    /// Build a [`JSXFragment`] and stores it in the memory arena.
+    /// Build a [`JSXFragment`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_fragment`] instead.
     ///
@@ -13020,7 +13020,7 @@ impl<'a> AstBuilder<'a> {
         JSXElementName::ThisExpression(inner.into_in(self.allocator))
     }
 
-    /// Build a [`JSXNamespacedName`]
+    /// Build a [`JSXNamespacedName`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_namespaced_name`] instead.
     ///
@@ -13038,7 +13038,7 @@ impl<'a> AstBuilder<'a> {
         JSXNamespacedName { span, namespace, property }
     }
 
-    /// Build a [`JSXNamespacedName`] and stores it in the memory arena.
+    /// Build a [`JSXNamespacedName`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_namespaced_name`] instead.
     ///
@@ -13056,7 +13056,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.jsx_namespaced_name(span, namespace, property), self.allocator)
     }
 
-    /// Build a [`JSXMemberExpression`]
+    /// Build a [`JSXMemberExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_member_expression`] instead.
     ///
@@ -13074,7 +13074,7 @@ impl<'a> AstBuilder<'a> {
         JSXMemberExpression { span, object, property }
     }
 
-    /// Build a [`JSXMemberExpression`] and stores it in the memory arena.
+    /// Build a [`JSXMemberExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_member_expression`] instead.
     ///
@@ -13183,7 +13183,7 @@ impl<'a> AstBuilder<'a> {
         JSXMemberExpressionObject::ThisExpression(inner.into_in(self.allocator))
     }
 
-    /// Build a [`JSXExpressionContainer`]
+    /// Build a [`JSXExpressionContainer`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_expression_container`] instead.
     ///
@@ -13199,7 +13199,7 @@ impl<'a> AstBuilder<'a> {
         JSXExpressionContainer { span, expression }
     }
 
-    /// Build a [`JSXExpressionContainer`] and stores it in the memory arena.
+    /// Build a [`JSXExpressionContainer`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_expression_container`] instead.
     ///
@@ -13239,7 +13239,7 @@ impl<'a> AstBuilder<'a> {
         JSXExpression::from(inner)
     }
 
-    /// Build a [`JSXEmptyExpression`]
+    /// Build a [`JSXEmptyExpression`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_empty_expression`] instead.
     ///
@@ -13250,7 +13250,7 @@ impl<'a> AstBuilder<'a> {
         JSXEmptyExpression { span }
     }
 
-    /// Build a [`JSXEmptyExpression`] and stores it in the memory arena.
+    /// Build a [`JSXEmptyExpression`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_empty_expression`] instead.
     ///
@@ -13313,7 +13313,7 @@ impl<'a> AstBuilder<'a> {
         JSXAttributeItem::SpreadAttribute(inner.into_in(self.allocator))
     }
 
-    /// Build a [`JSXAttribute`]
+    /// Build a [`JSXAttribute`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_attribute`] instead.
     ///
@@ -13331,7 +13331,7 @@ impl<'a> AstBuilder<'a> {
         JSXAttribute { span, name, value }
     }
 
-    /// Build a [`JSXAttribute`] and stores it in the memory arena.
+    /// Build a [`JSXAttribute`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_attribute`] instead.
     ///
@@ -13349,7 +13349,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.jsx_attribute(span, name, value), self.allocator)
     }
 
-    /// Build a [`JSXSpreadAttribute`]
+    /// Build a [`JSXSpreadAttribute`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_spread_attribute`] instead.
     ///
@@ -13365,7 +13365,7 @@ impl<'a> AstBuilder<'a> {
         JSXSpreadAttribute { span, argument }
     }
 
-    /// Build a [`JSXSpreadAttribute`] and stores it in the memory arena.
+    /// Build a [`JSXSpreadAttribute`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_spread_attribute`] instead.
     ///
@@ -13564,7 +13564,7 @@ impl<'a> AstBuilder<'a> {
         JSXAttributeValue::Fragment(inner.into_in(self.allocator))
     }
 
-    /// Build a [`JSXIdentifier`]
+    /// Build a [`JSXIdentifier`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_identifier`] instead.
     ///
@@ -13579,7 +13579,7 @@ impl<'a> AstBuilder<'a> {
         JSXIdentifier { span, name: name.into_in(self.allocator) }
     }
 
-    /// Build a [`JSXIdentifier`] and stores it in the memory arena.
+    /// Build a [`JSXIdentifier`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_identifier`] instead.
     ///
@@ -13740,7 +13740,7 @@ impl<'a> AstBuilder<'a> {
         JSXChild::Spread(inner.into_in(self.allocator))
     }
 
-    /// Build a [`JSXSpreadChild`]
+    /// Build a [`JSXSpreadChild`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_spread_child`] instead.
     ///
@@ -13752,7 +13752,7 @@ impl<'a> AstBuilder<'a> {
         JSXSpreadChild { span, expression }
     }
 
-    /// Build a [`JSXSpreadChild`] and stores it in the memory arena.
+    /// Build a [`JSXSpreadChild`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_spread_child`] instead.
     ///
@@ -13768,7 +13768,7 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.jsx_spread_child(span, expression), self.allocator)
     }
 
-    /// Build a [`JSXText`]
+    /// Build a [`JSXText`].
     ///
     /// If you want the built node to be allocated in the memory arena, use [`AstBuilder::alloc_jsx_text`] instead.
     ///
@@ -13783,7 +13783,7 @@ impl<'a> AstBuilder<'a> {
         JSXText { span, value: value.into_in(self.allocator) }
     }
 
-    /// Build a [`JSXText`] and stores it in the memory arena.
+    /// Build a [`JSXText`], and store it in the memory arena.
     ///
     /// Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::jsx_text`] instead.
     ///
diff --git a/tasks/ast_tools/src/generators/ast_builder.rs b/tasks/ast_tools/src/generators/ast_builder.rs
index f90b51f1d81b7..ed7dc449af748 100644
--- a/tasks/ast_tools/src/generators/ast_builder.rs
+++ b/tasks/ast_tools/src/generators/ast_builder.rs
@@ -285,12 +285,12 @@ fn generate_struct_builder_fn(ty: &StructDef, ctx: &LateCtx) -> TokenStream {
     let alloc_fn_name = format_ident!("alloc_{fn_name}");
 
     let article = article_for(ident.to_string());
-    let fn_docs = DocComment::new(format!("Build {article} [`{ident}`]"))
+    let fn_docs = DocComment::new(format!("Build {article} [`{ident}`]."))
         .with_description(format!("If you want the built node to be allocated in the memory arena, use [`AstBuilder::{alloc_fn_name}`] instead."))
         .with_params(&params);
 
     let alloc_docs =
-        DocComment::new(format!("Build {article} [`{ident}`] and stores it in the memory arena."))
+        DocComment::new(format!("Build {article} [`{ident}`], and store it in the memory arena."))
             .with_description(format!("Returns a [`Box`] containing the newly-allocated node. If you want a stack-allocated node, use [`AstBuilder::{fn_name}`] instead."))
             .with_params(&params);