use crate::{generated::nodes::*, JsSyntaxToken as SyntaxToken};
use biome_rowan::AstNode;
use std::iter::once;
impl JsAccessorModifier {
pub fn with_modifier_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsArrayAssignmentPattern {
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_elements(self, element: JsArrayAssignmentPatternElementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsArrayAssignmentPatternElement {
pub fn with_pattern(self, element: AnyJsAssignmentPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_init(self, element: Option<JsInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsArrayAssignmentPatternRestElement {
pub fn with_dotdotdot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_pattern(self, element: AnyJsAssignmentPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsArrayBindingPattern {
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_elements(self, element: JsArrayBindingPatternElementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsArrayBindingPatternElement {
pub fn with_pattern(self, element: AnyJsBindingPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_init(self, element: Option<JsInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsArrayBindingPatternRestElement {
pub fn with_dotdotdot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_pattern(self, element: AnyJsBindingPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsArrayExpression {
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_elements(self, element: JsArrayElementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsArrayHole {}
impl JsArrowFunctionExpression {
pub fn with_async_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: AnyJsArrowFunctionParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_fat_arrow_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: AnyJsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsAssignmentExpression {
pub fn with_left(self, element: AnyJsAssignmentPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_operator_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_right(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsAwaitExpression {
pub fn with_await_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_argument(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsBigintLiteralExpression {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsBinaryExpression {
pub fn with_left(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_operator_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_right(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsBlockStatement {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_statements(self, element: JsStatementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsBooleanLiteralExpression {
pub fn with_value_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsBreakStatement {
pub fn with_break_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_label(self, element: Option<JsLabel>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
}
impl JsCallArguments {
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_args(self, element: JsCallArgumentList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsCallExpression {
pub fn with_callee(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_optional_chain_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_type_arguments(self, element: Option<TsTypeArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_arguments(self, element: JsCallArguments) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsCaseClause {
pub fn with_case_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_test(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_consequent(self, element: JsStatementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsCatchClause {
pub fn with_catch_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_declaration(self, element: Option<JsCatchDeclaration>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_body(self, element: JsBlockStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsCatchDeclaration {
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_binding(self, element: AnyJsBindingPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_annotation(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
}
impl JsClassDeclaration {
pub fn with_decorators(self, element: JsDecoratorList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_abstract_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_class_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_id(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_extends_clause(self, element: Option<JsExtendsClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_implements_clause(self, element: Option<TsImplementsClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
6usize..=6usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(Some(element.into()))),
)
}
pub fn with_members(self, element: JsClassMemberList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(8usize..=8usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(9usize..=9usize, once(Some(element.into()))),
)
}
}
impl JsClassExportDefaultDeclaration {
pub fn with_decorators(self, element: JsDecoratorList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_abstract_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_class_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_id(self, element: Option<AnyJsBinding>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_extends_clause(self, element: Option<JsExtendsClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_implements_clause(self, element: Option<TsImplementsClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
6usize..=6usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(Some(element.into()))),
)
}
pub fn with_members(self, element: JsClassMemberList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(8usize..=8usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(9usize..=9usize, once(Some(element.into()))),
)
}
}
impl JsClassExpression {
pub fn with_decorators(self, element: JsDecoratorList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_class_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_id(self, element: Option<AnyJsBinding>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_extends_clause(self, element: Option<JsExtendsClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_implements_clause(self, element: Option<TsImplementsClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(Some(element.into()))),
)
}
pub fn with_members(self, element: JsClassMemberList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(8usize..=8usize, once(Some(element.into()))),
)
}
}
impl JsComputedMemberAssignment {
pub fn with_object(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_member(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
}
impl JsComputedMemberExpression {
pub fn with_object(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_optional_chain_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_member(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
}
impl JsComputedMemberName {
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsConditionalExpression {
pub fn with_test(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_question_mark_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_consequent(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_alternate(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsConstructorClassMember {
pub fn with_modifiers(self, element: JsConstructorModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_name(self, element: JsLiteralMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_parameters(self, element: JsConstructorParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_body(self, element: JsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsConstructorParameters {
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_parameters(self, element: JsConstructorParameterList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsContinueStatement {
pub fn with_continue_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_label(self, element: Option<JsLabel>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
}
impl JsDebuggerStatement {
pub fn with_debugger_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
}
impl JsDecorator {
pub fn with_at_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsDecorator) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsDefaultClause {
pub fn with_default_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_consequent(self, element: JsStatementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsDefaultImportSpecifier {
pub fn with_local_name(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsDirective {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
}
impl JsDoWhileStatement {
pub fn with_do_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: AnyJsStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_while_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_test(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(element.map(|element| element.into()))),
)
}
}
impl JsElseClause {
pub fn with_else_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_alternate(self, element: AnyJsStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsEmptyClassMember {
pub fn with_semicolon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsEmptyStatement {
pub fn with_semicolon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsExport {
pub fn with_decorators(self, element: JsDecoratorList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_export_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_export_clause(self, element: AnyJsExportClause) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsExportAsClause {
pub fn with_as_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_exported_name(self, element: JsLiteralExportName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsExportDefaultDeclarationClause {
pub fn with_default_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_declaration(self, element: AnyJsExportDefaultDeclaration) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
}
impl JsExportDefaultExpressionClause {
pub fn with_default_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
}
impl JsExportFromClause {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_star_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_export_as(self, element: Option<JsExportAsClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_from_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_source(self, element: JsModuleSource) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_assertion(self, element: Option<JsImportAssertion>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(element.map(|element| element.into()))),
)
}
}
impl JsExportNamedClause {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_specifiers(self, element: JsExportNamedSpecifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(element.map(|element| element.into()))),
)
}
}
impl JsExportNamedFromClause {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_specifiers(self, element: JsExportNamedFromSpecifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_from_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_source(self, element: JsModuleSource) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_assertion(self, element: Option<JsImportAssertion>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
6usize..=6usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(element.map(|element| element.into()))),
)
}
}
impl JsExportNamedFromSpecifier {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_source_name(self, element: JsLiteralExportName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_export_as(self, element: Option<JsExportAsClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsExportNamedShorthandSpecifier {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_name(self, element: JsReferenceIdentifier) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsExportNamedSpecifier {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_local_name(self, element: JsReferenceIdentifier) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_as_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_exported_name(self, element: JsLiteralExportName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsExpressionSnipped {
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_eof_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl JsExpressionStatement {
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
}
impl JsExtendsClause {
pub fn with_extends_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_super_class(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_arguments(self, element: Option<TsTypeArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsFinallyClause {
pub fn with_finally_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: JsBlockStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsForInStatement {
pub fn with_for_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_initializer(self, element: AnyJsForInOrOfInitializer) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_in_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: AnyJsStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsForOfStatement {
pub fn with_for_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_await_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_initializer(self, element: AnyJsForInOrOfInitializer) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_of_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: AnyJsStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsForStatement {
pub fn with_for_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_initializer(self, element: Option<AnyJsForInitializer>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_first_semi_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_test(self, element: Option<AnyJsExpression>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_second_semi_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into()))),
)
}
pub fn with_update(self, element: Option<AnyJsExpression>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
6usize..=6usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: AnyJsStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(8usize..=8usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsForVariableDeclaration {
pub fn with_await_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_kind_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_declarator(self, element: JsVariableDeclarator) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsFormalParameter {
pub fn with_decorators(self, element: JsDecoratorList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_binding(self, element: AnyJsBindingPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_question_mark_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
pub fn with_type_annotation(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_initializer(self, element: Option<JsInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsFunctionBody {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_directives(self, element: JsDirectiveList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_statements(self, element: JsStatementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
}
impl JsFunctionDeclaration {
pub fn with_async_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_function_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_star_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
pub fn with_id(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
6usize..=6usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_body(self, element: JsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsFunctionExportDefaultDeclaration {
pub fn with_async_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_function_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_star_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
pub fn with_id(self, element: Option<AnyJsBinding>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
6usize..=6usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_body(self, element: JsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsFunctionExpression {
pub fn with_async_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_function_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_star_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
pub fn with_id(self, element: Option<AnyJsBinding>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
6usize..=6usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_body(self, element: JsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsGetterClassMember {
pub fn with_modifiers(self, element: JsMethodModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_get_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsClassMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_return_type(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_body(self, element: JsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsGetterObjectMember {
pub fn with_get_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_return_type(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_body(self, element: JsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsIdentifierAssignment {
pub fn with_name_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsIdentifierBinding {
pub fn with_name_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsIdentifierExpression {
pub fn with_name(self, element: JsReferenceIdentifier) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsIfStatement {
pub fn with_if_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_test(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_consequent(self, element: AnyJsStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_else_clause(self, element: Option<JsElseClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsImport {
pub fn with_import_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_import_clause(self, element: AnyJsImportClause) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
}
impl JsImportAssertion {
pub fn with_assertion_kind_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_assertions(self, element: JsImportAssertionEntryList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
}
impl JsImportAssertionEntry {
pub fn with_key_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsImportBareClause {
pub fn with_source(self, element: JsModuleSource) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_assertion(self, element: Option<JsImportAssertion>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsImportCallExpression {
pub fn with_import_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_arguments(self, element: JsCallArguments) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsImportCombinedClause {
pub fn with_default_specifier(self, element: JsDefaultImportSpecifier) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_comma_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_specifier(self, element: AnyJsCombinedSpecifier) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_from_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_source(self, element: JsModuleSource) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_assertion(self, element: Option<JsImportAssertion>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsImportDefaultClause {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_default_specifier(self, element: JsDefaultImportSpecifier) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_from_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_source(self, element: JsModuleSource) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_assertion(self, element: Option<JsImportAssertion>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsImportMetaExpression {
pub fn with_import_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_dot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_meta_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsImportNamedClause {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_named_specifiers(self, element: JsNamedImportSpecifiers) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_from_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_source(self, element: JsModuleSource) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_assertion(self, element: Option<JsImportAssertion>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsImportNamespaceClause {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_namespace_specifier(self, element: JsNamespaceImportSpecifier) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_from_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_source(self, element: JsModuleSource) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_assertion(self, element: Option<JsImportAssertion>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsInExpression {
pub fn with_property(self, element: AnyJsInProperty) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_in_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_object(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsInitializerClause {
pub fn with_eq_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsInstanceofExpression {
pub fn with_left(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_instanceof_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_right(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsLabel {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsLabeledStatement {
pub fn with_label(self, element: JsLabel) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: AnyJsStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsLiteralExportName {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsLiteralMemberName {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsLogicalExpression {
pub fn with_left(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_operator_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_right(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsMethodClassMember {
pub fn with_modifiers(self, element: JsMethodModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_async_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_star_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
pub fn with_name(self, element: AnyJsClassMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_question_mark_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(element.map(|element| element.into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
7usize..=7usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_body(self, element: JsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(8usize..=8usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsMethodObjectMember {
pub fn with_async_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_star_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_name(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_body(self, element: JsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsModule {
pub fn with_bom_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_interpreter_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_directives(self, element: JsDirectiveList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_items(self, element: JsModuleItemList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_eof_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
}
impl JsModuleSource {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsName {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsNamedImportSpecifier {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_name(self, element: JsLiteralExportName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_as_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_local_name(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsNamedImportSpecifiers {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_specifiers(self, element: JsNamedImportSpecifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsNamespaceImportSpecifier {
pub fn with_star_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_as_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_local_name(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsNewExpression {
pub fn with_new_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_callee(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_arguments(self, element: Option<TsTypeArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_arguments(self, element: Option<JsCallArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsNewTargetExpression {
pub fn with_new_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_dot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_target_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsNullLiteralExpression {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsNumberLiteralExpression {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsObjectAssignmentPattern {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_properties(self, element: JsObjectAssignmentPatternPropertyList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsObjectAssignmentPatternProperty {
pub fn with_member(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_pattern(self, element: AnyJsAssignmentPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_init(self, element: Option<JsInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsObjectAssignmentPatternRest {
pub fn with_dotdotdot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_target(self, element: AnyJsAssignment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsObjectAssignmentPatternShorthandProperty {
pub fn with_identifier(self, element: JsIdentifierAssignment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_init(self, element: Option<JsInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsObjectBindingPattern {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_properties(self, element: JsObjectBindingPatternPropertyList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsObjectBindingPatternProperty {
pub fn with_member(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_pattern(self, element: AnyJsBindingPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_init(self, element: Option<JsInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsObjectBindingPatternRest {
pub fn with_dotdotdot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_binding(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsObjectBindingPatternShorthandProperty {
pub fn with_identifier(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_init(self, element: Option<JsInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsObjectExpression {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_members(self, element: JsObjectMemberList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsParameters {
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_items(self, element: JsParameterList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsParenthesizedAssignment {
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_assignment(self, element: AnyJsAssignment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsParenthesizedExpression {
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsPostUpdateExpression {
pub fn with_operand(self, element: AnyJsAssignment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_operator_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl JsPreUpdateExpression {
pub fn with_operator_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_operand(self, element: AnyJsAssignment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsPrivateClassMemberName {
pub fn with_hash_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_id_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl JsPrivateName {
pub fn with_hash_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl JsPropertyClassMember {
pub fn with_modifiers(self, element: JsPropertyModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_name(self, element: AnyJsClassMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_property_annotation(self, element: Option<AnyTsPropertyAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_value(self, element: Option<JsInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(element.map(|element| element.into()))),
)
}
}
impl JsPropertyObjectMember {
pub fn with_name(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_value(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsReferenceIdentifier {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsRegexLiteralExpression {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsRestParameter {
pub fn with_decorators(self, element: JsDecoratorList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_dotdotdot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_binding(self, element: AnyJsBindingPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_annotation(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsReturnStatement {
pub fn with_return_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_argument(self, element: Option<AnyJsExpression>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
}
impl JsScript {
pub fn with_bom_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_interpreter_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_directives(self, element: JsDirectiveList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_statements(self, element: JsStatementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_eof_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
}
impl JsSequenceExpression {
pub fn with_left(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_comma_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_right(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsSetterClassMember {
pub fn with_modifiers(self, element: JsMethodModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_set_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsClassMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_parameter(self, element: AnyJsFormalParameter) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: JsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsSetterObjectMember {
pub fn with_set_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_parameter(self, element: AnyJsFormalParameter) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: JsFunctionBody) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsShorthandNamedImportSpecifier {
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_local_name(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsShorthandPropertyObjectMember {
pub fn with_name(self, element: JsReferenceIdentifier) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsSpread {
pub fn with_dotdotdot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_argument(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsStaticInitializationBlockClassMember {
pub fn with_static_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_statements(self, element: JsStatementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
}
impl JsStaticMemberAssignment {
pub fn with_object(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_dot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_member(self, element: AnyJsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsStaticMemberExpression {
pub fn with_object(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_operator_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_member(self, element: AnyJsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsStaticModifier {
pub fn with_modifier_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsStringLiteralExpression {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsSuperExpression {
pub fn with_super_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsSwitchStatement {
pub fn with_switch_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_discriminant(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_cases(self, element: JsSwitchCaseList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(Some(element.into()))),
)
}
}
impl JsTemplateChunkElement {
pub fn with_template_chunk_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsTemplateElement {
pub fn with_dollar_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsTemplateExpression {
pub fn with_tag(self, element: Option<AnyJsExpression>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
0usize..=0usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_type_arguments(self, element: Option<TsTypeArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_l_tick_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_elements(self, element: JsTemplateElementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_tick_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
}
impl JsThisExpression {
pub fn with_this_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsThrowStatement {
pub fn with_throw_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_argument(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
}
impl JsTryFinallyStatement {
pub fn with_try_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: JsBlockStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_catch_clause(self, element: Option<JsCatchClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_finally_clause(self, element: JsFinallyClause) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsTryStatement {
pub fn with_try_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: JsBlockStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_catch_clause(self, element: JsCatchClause) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsUnaryExpression {
pub fn with_operator_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_argument(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsVariableDeclaration {
pub fn with_await_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_kind_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_declarators(self, element: JsVariableDeclaratorList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsVariableDeclarationClause {
pub fn with_declaration(self, element: JsVariableDeclaration) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
}
impl JsVariableDeclarator {
pub fn with_id(self, element: AnyJsBindingPattern) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_variable_annotation(self, element: Option<AnyTsVariableAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_initializer(self, element: Option<JsInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsVariableStatement {
pub fn with_declaration(self, element: JsVariableDeclaration) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
}
impl JsWhileStatement {
pub fn with_while_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_test(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: AnyJsStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsWithStatement {
pub fn with_with_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_object(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: AnyJsStatement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsYieldArgument {
pub fn with_star_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsYieldExpression {
pub fn with_yield_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_argument(self, element: Option<JsYieldArgument>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsxAttribute {
pub fn with_name(self, element: AnyJsxAttributeName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_initializer(self, element: Option<JsxAttributeInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl JsxAttributeInitializerClause {
pub fn with_eq_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_value(self, element: AnyJsxAttributeValue) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsxClosingElement {
pub fn with_l_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_slash_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsxElementName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
}
impl JsxClosingFragment {
pub fn with_l_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_slash_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_r_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsxElement {
pub fn with_opening_element(self, element: JsxOpeningElement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_children(self, element: JsxChildList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_closing_element(self, element: JsxClosingElement) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsxExpressionAttributeValue {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsxExpressionChild {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: Option<AnyJsExpression>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl JsxFragment {
pub fn with_opening_fragment(self, element: JsxOpeningFragment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_children(self, element: JsxChildList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_closing_fragment(self, element: JsxClosingFragment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsxMemberName {
pub fn with_object(self, element: AnyJsxObjectName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_dot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_member(self, element: JsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsxName {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsxNamespaceName {
pub fn with_namespace(self, element: JsxName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: JsxName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsxOpeningElement {
pub fn with_l_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsxElementName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_arguments(self, element: Option<TsTypeArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_attributes(self, element: JsxAttributeList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
}
impl JsxOpeningFragment {
pub fn with_l_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_r_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl JsxReferenceIdentifier {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsxSelfClosingElement {
pub fn with_l_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsxElementName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_arguments(self, element: Option<TsTypeArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_attributes(self, element: JsxAttributeList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_slash_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_r_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into()))),
)
}
}
impl JsxSpreadAttribute {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_dotdotdot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_argument(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
}
impl JsxSpreadChild {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_dotdotdot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
}
impl JsxString {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl JsxTagExpression {
pub fn with_tag(self, element: AnyJsxTag) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
}
impl JsxText {
pub fn with_value_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsAbstractModifier {
pub fn with_modifier_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsAccessibilityModifier {
pub fn with_modifier_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsAnyType {
pub fn with_any_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsArrayType {
pub fn with_element_type(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl TsAsAssignment {
pub fn with_assignment(self, element: AnyJsAssignment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_as_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsAsExpression {
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_as_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsAssertsCondition {
pub fn with_is_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsAssertsReturnType {
pub fn with_asserts_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_parameter_name(self, element: AnyTsTypePredicateParameterName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_predicate(self, element: Option<TsAssertsCondition>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsBigintLiteralType {
pub fn with_minus_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_literal_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl TsBigintType {
pub fn with_bigint_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsBooleanLiteralType {
pub fn with_literal_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsBooleanType {
pub fn with_boolean_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsCallSignatureTypeMember {
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
0usize..=0usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_separator_token_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(element.map(|element| element.into()))),
)
}
}
impl TsConditionalType {
pub fn with_check_type(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_extends_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_extends_type(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_question_mark_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_true_type(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into()))),
)
}
pub fn with_false_type(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsConstModifier {
pub fn with_modifier_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsConstructSignatureTypeMember {
pub fn with_new_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_annotation(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_separator_token_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(element.map(|element| element.into()))),
)
}
}
impl TsConstructorSignatureClassMember {
pub fn with_modifiers(self, element: JsConstructorModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_name(self, element: JsLiteralMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_parameters(self, element: JsConstructorParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(element.map(|element| element.into()))),
)
}
}
impl TsConstructorType {
pub fn with_abstract_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_new_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_fat_arrow_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_return_type(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsDeclareFunctionDeclaration {
pub fn with_async_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_function_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_id(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(element.map(|element| element.into()))),
)
}
}
impl TsDeclareFunctionExportDefaultDeclaration {
pub fn with_async_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_function_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_id(self, element: Option<AnyJsBinding>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(element.map(|element| element.into()))),
)
}
}
impl TsDeclareModifier {
pub fn with_modifier_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsDeclareStatement {
pub fn with_declare_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_declaration(self, element: AnyJsDeclarationClause) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsDefaultTypeClause {
pub fn with_eq_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsDefinitePropertyAnnotation {
pub fn with_excl_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_type_annotation(self, element: TsTypeAnnotation) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsDefiniteVariableAnnotation {
pub fn with_excl_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_type_annotation(self, element: TsTypeAnnotation) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsEmptyExternalModuleDeclarationBody {
pub fn with_semicolon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsEnumDeclaration {
pub fn with_const_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_enum_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_id(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_members(self, element: TsEnumMemberList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into()))),
)
}
}
impl TsEnumMember {
pub fn with_name(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_initializer(self, element: Option<JsInitializerClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsExportAsNamespaceClause {
pub fn with_as_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_namespace_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: JsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(element.map(|element| element.into()))),
)
}
}
impl TsExportAssignmentClause {
pub fn with_eq_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
}
impl TsExportDeclareClause {
pub fn with_declare_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_declaration(self, element: AnyJsDeclarationClause) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsExtendsClause {
pub fn with_extends_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_types(self, element: TsTypeList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsExternalModuleDeclaration {
pub fn with_module_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_source(self, element: JsModuleSource) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_body(self, element: Option<AnyTsExternalModuleDeclarationBody>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsExternalModuleReference {
pub fn with_require_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_source(self, element: JsModuleSource) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
}
impl TsFunctionType {
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
0usize..=0usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_fat_arrow_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_return_type(self, element: AnyTsReturnType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsGetterSignatureClassMember {
pub fn with_modifiers(self, element: TsMethodSignatureModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_get_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsClassMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_return_type(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(element.map(|element| element.into()))),
)
}
}
impl TsGetterSignatureTypeMember {
pub fn with_get_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_type_annotation(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_separator_token_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(element.map(|element| element.into()))),
)
}
}
impl TsGlobalDeclaration {
pub fn with_global_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_body(self, element: TsModuleBlock) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsIdentifierBinding {
pub fn with_name_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsImplementsClause {
pub fn with_implements_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_types(self, element: TsTypeList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsImportEqualsDeclaration {
pub fn with_import_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_type_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_id(self, element: AnyJsBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_eq_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_module_reference(self, element: AnyTsModuleReference) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(element.map(|element| element.into()))),
)
}
}
impl TsImportType {
pub fn with_typeof_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_import_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_argument_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_qualifier_clause(self, element: Option<TsImportTypeQualifier>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
5usize..=5usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_type_arguments(self, element: Option<TsTypeArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
6usize..=6usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsImportTypeQualifier {
pub fn with_dot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_right(self, element: AnyTsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsInModifier {
pub fn with_modifier_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsIndexSignatureClassMember {
pub fn with_modifiers(self, element: TsIndexSignatureModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_parameter(self, element: TsIndexSignatureParameter) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_type_annotation(self, element: TsTypeAnnotation) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(element.map(|element| element.into()))),
)
}
}
impl TsIndexSignatureParameter {
pub fn with_binding(self, element: JsIdentifierBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_annotation(self, element: TsTypeAnnotation) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsIndexSignatureTypeMember {
pub fn with_readonly_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_parameter(self, element: TsIndexSignatureParameter) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_type_annotation(self, element: TsTypeAnnotation) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_separator_token_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(element.map(|element| element.into()))),
)
}
}
impl TsIndexedAccessType {
pub fn with_object_type(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_index_type(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
}
impl TsInferType {
pub fn with_infer_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: TsTypeParameterName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_constraint(self, element: Option<TsTypeConstraintClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsInitializedPropertySignatureClassMember {
pub fn with_modifiers(self, element: TsPropertySignatureModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_name(self, element: AnyJsClassMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_question_mark_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
pub fn with_value(self, element: JsInitializerClause) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(element.map(|element| element.into()))),
)
}
}
impl TsInstantiationExpression {
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_arguments(self, element: TsTypeArguments) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsInterfaceDeclaration {
pub fn with_interface_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_id(self, element: TsIdentifierBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_extends_clause(self, element: Option<TsExtendsClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_members(self, element: TsTypeMemberList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(Some(element.into()))),
)
}
}
impl TsIntersectionType {
pub fn with_leading_separator_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_types(self, element: TsIntersectionTypeElementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsMappedType {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_readonly_modifier(
self,
element: Option<TsMappedTypeReadonlyModifierClause>,
) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_property_name(self, element: TsTypeParameterName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_in_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_keys_type(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_as_clause(self, element: Option<TsMappedTypeAsClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
6usize..=6usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(Some(element.into()))),
)
}
pub fn with_optional_modifier(
self,
element: Option<TsMappedTypeOptionalModifierClause>,
) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
8usize..=8usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_mapped_type(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
9usize..=9usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
10usize..=10usize,
once(element.map(|element| element.into())),
))
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(11usize..=11usize, once(Some(element.into()))),
)
}
}
impl TsMappedTypeAsClause {
pub fn with_as_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsMappedTypeOptionalModifierClause {
pub fn with_operator_token_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_question_mark_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl TsMappedTypeReadonlyModifierClause {
pub fn with_operator_token_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_readonly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl TsMethodSignatureClassMember {
pub fn with_modifiers(self, element: TsMethodSignatureModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_async_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_name(self, element: AnyJsClassMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_question_mark_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(element.map(|element| element.into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
6usize..=6usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(7usize..=7usize, once(element.map(|element| element.into()))),
)
}
}
impl TsMethodSignatureTypeMember {
pub fn with_name(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_optional_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(element.map(|element| element.into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_parameters(self, element: JsParameters) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_return_type_annotation(self, element: Option<TsReturnTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
4usize..=4usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_separator_token_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(element.map(|element| element.into()))),
)
}
}
impl TsModuleBlock {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_items(self, element: JsModuleItemList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl TsModuleDeclaration {
pub fn with_module_or_namespace_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyTsModuleName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_body(self, element: TsModuleBlock) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsNameWithTypeArguments {
pub fn with_name(self, element: AnyTsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_arguments(self, element: Option<TsTypeArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsNamedTupleTypeElement {
pub fn with_dotdotdot_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_name(self, element: JsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_question_mark_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsNeverType {
pub fn with_never_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsNonNullAssertionAssignment {
pub fn with_assignment(self, element: AnyJsAssignment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_excl_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl TsNonNullAssertionExpression {
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_excl_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl TsNonPrimitiveType {
pub fn with_object_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsNullLiteralType {
pub fn with_literal_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsNumberLiteralType {
pub fn with_minus_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_literal_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl TsNumberType {
pub fn with_number_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsObjectType {
pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_members(self, element: TsTypeMemberList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl TsOptionalPropertyAnnotation {
pub fn with_question_mark_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_type_annotation(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsOptionalTupleTypeElement {
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_question_mark_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
}
impl TsOutModifier {
pub fn with_modifier_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsOverrideModifier {
pub fn with_modifier_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsParenthesizedType {
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl TsPredicateReturnType {
pub fn with_parameter_name(self, element: AnyTsTypePredicateParameterName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_is_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsPropertyParameter {
pub fn with_decorators(self, element: JsDecoratorList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_modifiers(self, element: TsPropertyParameterModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_formal_parameter(self, element: AnyJsFormalParameter) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsPropertySignatureClassMember {
pub fn with_modifiers(self, element: TsPropertySignatureModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_name(self, element: AnyJsClassMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_property_annotation(
self,
element: Option<AnyTsPropertySignatureAnnotation>,
) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(element.map(|element| element.into()))),
)
}
}
impl TsPropertySignatureTypeMember {
pub fn with_readonly_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_name(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_optional_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(element.map(|element| element.into()))),
)
}
pub fn with_type_annotation(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_separator_token_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(element.map(|element| element.into()))),
)
}
}
impl TsQualifiedModuleName {
pub fn with_left(self, element: AnyTsModuleName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_dot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_right(self, element: JsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsQualifiedName {
pub fn with_left(self, element: AnyTsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_dot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_right(self, element: JsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsReadonlyModifier {
pub fn with_modifier_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsReferenceType {
pub fn with_name(self, element: AnyTsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_arguments(self, element: Option<TsTypeArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsRestTupleTypeElement {
pub fn with_dotdotdot_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsReturnTypeAnnotation {
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsReturnType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsSatisfiesAssignment {
pub fn with_assignment(self, element: AnyJsAssignment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_satisfies_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsSatisfiesExpression {
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_satisfies_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsSetterSignatureClassMember {
pub fn with_modifiers(self, element: TsMethodSignatureModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_set_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsClassMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_parameter(self, element: AnyJsFormalParameter) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(Some(element.into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(6usize..=6usize, once(element.map(|element| element.into()))),
)
}
}
impl TsSetterSignatureTypeMember {
pub fn with_set_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_name(self, element: AnyJsObjectMemberName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_l_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_parameter(self, element: AnyJsFormalParameter) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_paren_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into()))),
)
}
pub fn with_separator_token_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(element.map(|element| element.into()))),
)
}
}
impl TsStringLiteralType {
pub fn with_literal_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsStringType {
pub fn with_string_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsSymbolType {
pub fn with_symbol_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsTemplateChunkElement {
pub fn with_template_chunk_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsTemplateElement {
pub fn with_dollar_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl TsTemplateLiteralType {
pub fn with_l_tick_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_elements(self, element: TsTemplateElementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_tick_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl TsThisParameter {
pub fn with_this_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_type_annotation(self, element: Option<TsTypeAnnotation>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
1usize..=1usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsThisType {
pub fn with_this_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsTupleType {
pub fn with_l_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_elements(self, element: TsTupleTypeElementList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_brack_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl TsTypeAliasDeclaration {
pub fn with_type_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_binding_identifier(self, element: TsIdentifierBinding) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_parameters(self, element: Option<TsTypeParameters>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_eq_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(4usize..=4usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_semicolon_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(5usize..=5usize, once(element.map(|element| element.into()))),
)
}
}
impl TsTypeAnnotation {
pub fn with_colon_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsTypeArguments {
pub fn with_l_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ts_type_argument_list(self, element: TsTypeArgumentList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl TsTypeAssertionAssignment {
pub fn with_l_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_assignment(self, element: AnyJsAssignment) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsTypeAssertionExpression {
pub fn with_l_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
pub fn with_expression(self, element: AnyJsExpression) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsTypeConstraintClause {
pub fn with_extends_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsTypeOperatorType {
pub fn with_operator_token_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_ty(self, element: AnyTsType) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsTypeParameter {
pub fn with_modifiers(self, element: TsTypeParameterModifierList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_name(self, element: TsTypeParameterName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_constraint(self, element: Option<TsTypeConstraintClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
pub fn with_default(self, element: Option<TsDefaultTypeClause>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
3usize..=3usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsTypeParameterName {
pub fn with_ident_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsTypeParameters {
pub fn with_l_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_items(self, element: TsTypeParameterList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_r_angle_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(2usize..=2usize, once(Some(element.into()))),
)
}
}
impl TsTypeofType {
pub fn with_typeof_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
pub fn with_expression_name(self, element: AnyTsName) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
pub fn with_type_arguments(self, element: Option<TsTypeArguments>) -> Self {
Self::unwrap_cast(self.syntax.splice_slots(
2usize..=2usize,
once(element.map(|element| element.into_syntax().into())),
))
}
}
impl TsUndefinedType {
pub fn with_undefined_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsUnionType {
pub fn with_leading_separator_token(self, element: Option<SyntaxToken>) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
)
}
pub fn with_types(self, element: TsUnionTypeVariantList) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
)
}
}
impl TsUnknownType {
pub fn with_unknown_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}
impl TsVoidType {
pub fn with_void_token(self, element: SyntaxToken) -> Self {
Self::unwrap_cast(
self.syntax
.splice_slots(0usize..=0usize, once(Some(element.into()))),
)
}
}