syntax/ast/syntax_factory/
constructors.rs

1//! Wrappers over [`make`] constructors
2use crate::{
3    AstNode, NodeOrToken, SyntaxKind, SyntaxNode, SyntaxToken,
4    ast::{
5        self, HasArgList, HasAttrs, HasGenericArgs, HasGenericParams, HasLoopBody, HasName,
6        HasTypeBounds, HasVisibility, RangeItem, make,
7    },
8    syntax_editor::SyntaxMappingBuilder,
9};
10
11use super::SyntaxFactory;
12
13impl SyntaxFactory {
14    pub fn name(&self, name: &str) -> ast::Name {
15        make::name(name).clone_for_update()
16    }
17
18    pub fn name_ref(&self, name: &str) -> ast::NameRef {
19        make::name_ref(name).clone_for_update()
20    }
21
22    pub fn lifetime(&self, text: &str) -> ast::Lifetime {
23        make::lifetime(text).clone_for_update()
24    }
25
26    pub fn ty(&self, text: &str) -> ast::Type {
27        make::ty(text).clone_for_update()
28    }
29
30    pub fn ty_infer(&self) -> ast::InferType {
31        let ast::Type::InferType(ast) = make::ty_placeholder().clone_for_update() else {
32            unreachable!()
33        };
34
35        ast
36    }
37
38    pub fn ty_path(&self, path: ast::Path) -> ast::PathType {
39        let ast::Type::PathType(ast) = make::ty_path(path.clone()).clone_for_update() else {
40            unreachable!()
41        };
42
43        if let Some(mut mapping) = self.mappings() {
44            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
45            builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
46            builder.finish(&mut mapping);
47        }
48
49        ast
50    }
51
52    pub fn type_param(
53        &self,
54        name: ast::Name,
55        bounds: Option<ast::TypeBoundList>,
56    ) -> ast::TypeParam {
57        let ast = make::type_param(name.clone(), bounds.clone()).clone_for_update();
58
59        if let Some(mut mapping) = self.mappings() {
60            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
61            builder.map_node(name.syntax().clone(), ast.name().unwrap().syntax().clone());
62            if let Some(input) = bounds {
63                builder.map_node(
64                    input.syntax().clone(),
65                    ast.type_bound_list().unwrap().syntax().clone(),
66                );
67            }
68            builder.finish(&mut mapping);
69        }
70
71        ast
72    }
73
74    pub fn path_from_text(&self, text: &str) -> ast::Path {
75        make::path_from_text(text).clone_for_update()
76    }
77
78    pub fn expr_field(&self, receiver: ast::Expr, field: &str) -> ast::FieldExpr {
79        let ast::Expr::FieldExpr(ast) =
80            make::expr_field(receiver.clone(), field).clone_for_update()
81        else {
82            unreachable!()
83        };
84
85        if let Some(mut mapping) = self.mappings() {
86            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
87            builder.map_node(receiver.syntax().clone(), ast.expr().unwrap().syntax().clone());
88            builder.finish(&mut mapping);
89        }
90
91        ast
92    }
93
94    pub fn impl_trait(
95        &self,
96        attrs: impl IntoIterator<Item = ast::Attr>,
97        is_unsafe: bool,
98        trait_gen_params: Option<ast::GenericParamList>,
99        trait_gen_args: Option<ast::GenericArgList>,
100        type_gen_params: Option<ast::GenericParamList>,
101        type_gen_args: Option<ast::GenericArgList>,
102        is_negative: bool,
103        path_type: ast::Type,
104        ty: ast::Type,
105        trait_where_clause: Option<ast::WhereClause>,
106        ty_where_clause: Option<ast::WhereClause>,
107        body: Option<ast::AssocItemList>,
108    ) -> ast::Impl {
109        let (attrs, attrs_input) = iterator_input(attrs);
110        let ast = make::impl_trait(
111            attrs,
112            is_unsafe,
113            trait_gen_params.clone(),
114            trait_gen_args.clone(),
115            type_gen_params.clone(),
116            type_gen_args.clone(),
117            is_negative,
118            path_type.clone(),
119            ty.clone(),
120            trait_where_clause.clone(),
121            ty_where_clause.clone(),
122            body.clone(),
123        )
124        .clone_for_update();
125
126        if let Some(mut mapping) = self.mappings() {
127            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
128            builder.map_children(attrs_input, ast.attrs().map(|attr| attr.syntax().clone()));
129            if let Some(trait_gen_params) = trait_gen_params {
130                builder.map_node(
131                    trait_gen_params.syntax().clone(),
132                    ast.generic_param_list().unwrap().syntax().clone(),
133                );
134            }
135            builder.map_node(path_type.syntax().clone(), ast.trait_().unwrap().syntax().clone());
136            builder.map_node(ty.syntax().clone(), ast.self_ty().unwrap().syntax().clone());
137            if let Some(ty_where_clause) = ty_where_clause {
138                builder.map_node(
139                    ty_where_clause.syntax().clone(),
140                    ast.where_clause().unwrap().syntax().clone(),
141                );
142            }
143            if let Some(body) = body {
144                builder.map_node(
145                    body.syntax().clone(),
146                    ast.assoc_item_list().unwrap().syntax().clone(),
147                );
148            }
149            builder.finish(&mut mapping);
150        }
151
152        ast
153    }
154
155    pub fn ty_alias(
156        &self,
157        attrs: impl IntoIterator<Item = ast::Attr>,
158        ident: &str,
159        generic_param_list: Option<ast::GenericParamList>,
160        type_param_bounds: Option<ast::TypeParam>,
161        where_clause: Option<ast::WhereClause>,
162        assignment: Option<(ast::Type, Option<ast::WhereClause>)>,
163    ) -> ast::TypeAlias {
164        let (attrs, attrs_input) = iterator_input(attrs);
165        let ast = make::ty_alias(
166            attrs,
167            ident,
168            generic_param_list.clone(),
169            type_param_bounds.clone(),
170            where_clause.clone(),
171            assignment.clone(),
172        )
173        .clone_for_update();
174
175        if let Some(mut mapping) = self.mappings() {
176            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
177            builder.map_children(attrs_input, ast.attrs().map(|attr| attr.syntax().clone()));
178            if let Some(generic_param_list) = generic_param_list {
179                builder.map_node(
180                    generic_param_list.syntax().clone(),
181                    ast.generic_param_list().unwrap().syntax().clone(),
182                );
183            }
184            if let Some(type_param_bounds) = type_param_bounds {
185                builder.map_node(
186                    type_param_bounds.syntax().clone(),
187                    ast.type_bound_list().unwrap().syntax().clone(),
188                );
189            }
190            if let Some(where_clause) = where_clause {
191                builder.map_node(
192                    where_clause.syntax().clone(),
193                    ast.where_clause().unwrap().syntax().clone(),
194                );
195            }
196            if let Some((ty, _)) = assignment {
197                builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
198            }
199            builder.finish(&mut mapping);
200        }
201
202        ast
203    }
204
205    pub fn param_list(
206        &self,
207        self_param: Option<ast::SelfParam>,
208        params: impl IntoIterator<Item = ast::Param>,
209    ) -> ast::ParamList {
210        let (params, input) = iterator_input(params);
211        let ast = make::param_list(self_param.clone(), params).clone_for_update();
212
213        if let Some(mut mapping) = self.mappings() {
214            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
215            if let Some(self_param) = self_param
216                && let Some(new_self_param) = ast.self_param()
217            {
218                builder.map_node(self_param.syntax().clone(), new_self_param.syntax().clone());
219            }
220            builder.map_children(input, ast.params().map(|p| p.syntax().clone()));
221            builder.finish(&mut mapping);
222        }
223
224        ast
225    }
226
227    pub fn const_param(&self, name: ast::Name, ty: ast::Type) -> ast::ConstParam {
228        let ast = make::const_param(name.clone(), ty.clone()).clone_for_update();
229
230        if let Some(mut mapping) = self.mappings() {
231            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
232            builder.map_node(name.syntax().clone(), ast.name().unwrap().syntax().clone());
233            builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
234            builder.finish(&mut mapping);
235        }
236
237        ast
238    }
239
240    pub fn generic_param_list(
241        &self,
242        params: impl IntoIterator<Item = ast::GenericParam>,
243    ) -> ast::GenericParamList {
244        let (params, input) = iterator_input(params);
245        let ast = make::generic_param_list(params).clone_for_update();
246
247        if let Some(mut mapping) = self.mappings() {
248            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
249            builder.map_children(input, ast.generic_params().map(|p| p.syntax().clone()));
250            builder.finish(&mut mapping);
251        }
252
253        ast
254    }
255
256    pub fn path_segment(&self, name_ref: ast::NameRef) -> ast::PathSegment {
257        let ast = make::path_segment(name_ref.clone()).clone_for_update();
258
259        if let Some(mut mapping) = self.mappings() {
260            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
261            builder.map_node(name_ref.syntax().clone(), ast.name_ref().unwrap().syntax().clone());
262            builder.finish(&mut mapping);
263        }
264
265        ast
266    }
267
268    pub fn path_segment_generics(
269        &self,
270        name_ref: ast::NameRef,
271        generic_arg_list: ast::GenericArgList,
272    ) -> ast::PathSegment {
273        let ast::Type::PathType(path) = make::ty(&format!("{name_ref}{generic_arg_list}")) else {
274            unreachable!();
275        };
276
277        let ast = path.path().unwrap().segment().unwrap().clone_for_update();
278
279        if let Some(mut mapping) = self.mappings() {
280            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
281            builder.map_node(name_ref.syntax().clone(), ast.name_ref().unwrap().syntax().clone());
282            builder.map_node(
283                generic_arg_list.syntax().clone(),
284                ast.generic_arg_list().unwrap().syntax().clone(),
285            );
286            builder.finish(&mut mapping);
287        }
288
289        ast
290    }
291
292    pub fn use_(
293        &self,
294        attrs: impl IntoIterator<Item = ast::Attr>,
295        visibility: Option<ast::Visibility>,
296        use_tree: ast::UseTree,
297    ) -> ast::Use {
298        make::use_(attrs, visibility, use_tree).clone_for_update()
299    }
300
301    pub fn use_tree(
302        &self,
303        path: ast::Path,
304        use_tree_list: Option<ast::UseTreeList>,
305        alias: Option<ast::Rename>,
306        add_star: bool,
307    ) -> ast::UseTree {
308        make::use_tree(path, use_tree_list, alias, add_star).clone_for_update()
309    }
310
311    pub fn path_unqualified(&self, segment: ast::PathSegment) -> ast::Path {
312        let ast = make::path_unqualified(segment.clone()).clone_for_update();
313
314        if let Some(mut mapping) = self.mappings() {
315            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
316            builder.map_node(segment.syntax().clone(), ast.segment().unwrap().syntax().clone());
317            builder.finish(&mut mapping);
318        }
319
320        ast
321    }
322
323    pub fn path_from_segments(
324        &self,
325        segments: impl IntoIterator<Item = ast::PathSegment>,
326        is_abs: bool,
327    ) -> ast::Path {
328        let (segments, input) = iterator_input(segments);
329        let ast = make::path_from_segments(segments, is_abs).clone_for_update();
330
331        if let Some(mut mapping) = self.mappings() {
332            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
333            builder.map_children(input, ast.segments().map(|it| it.syntax().clone()));
334            builder.finish(&mut mapping);
335        }
336
337        ast
338    }
339
340    pub fn ident_pat(&self, ref_: bool, mut_: bool, name: ast::Name) -> ast::IdentPat {
341        let ast = make::ident_pat(ref_, mut_, name.clone()).clone_for_update();
342
343        if let Some(mut mapping) = self.mappings() {
344            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
345            builder.map_node(name.syntax().clone(), ast.name().unwrap().syntax().clone());
346            builder.finish(&mut mapping);
347        }
348
349        ast
350    }
351
352    pub fn wildcard_pat(&self) -> ast::WildcardPat {
353        make::wildcard_pat().clone_for_update()
354    }
355
356    pub fn literal_pat(&self, text: &str) -> ast::LiteralPat {
357        make::literal_pat(text).clone_for_update()
358    }
359
360    pub fn slice_pat(&self, pats: impl IntoIterator<Item = ast::Pat>) -> ast::SlicePat {
361        let (pats, input) = iterator_input(pats);
362        let ast = make::slice_pat(pats).clone_for_update();
363
364        if let Some(mut mapping) = self.mappings() {
365            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
366            builder.map_children(input, ast.pats().map(|it| it.syntax().clone()));
367            builder.finish(&mut mapping);
368        }
369
370        ast
371    }
372
373    pub fn tuple_pat(&self, pats: impl IntoIterator<Item = ast::Pat>) -> ast::TuplePat {
374        let (pats, input) = iterator_input(pats);
375        let ast = make::tuple_pat(pats).clone_for_update();
376
377        if let Some(mut mapping) = self.mappings() {
378            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
379            builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
380            builder.finish(&mut mapping);
381        }
382
383        ast
384    }
385
386    pub fn tuple_struct_pat(
387        &self,
388        path: ast::Path,
389        fields: impl IntoIterator<Item = ast::Pat>,
390    ) -> ast::TupleStructPat {
391        let (fields, input) = iterator_input(fields);
392        let ast = make::tuple_struct_pat(path.clone(), fields).clone_for_update();
393
394        if let Some(mut mapping) = self.mappings() {
395            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
396            builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
397            builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
398            builder.finish(&mut mapping);
399        }
400
401        ast
402    }
403
404    pub fn record_pat_with_fields(
405        &self,
406        path: ast::Path,
407        fields: ast::RecordPatFieldList,
408    ) -> ast::RecordPat {
409        let ast = make::record_pat_with_fields(path.clone(), fields.clone()).clone_for_update();
410
411        if let Some(mut mapping) = self.mappings() {
412            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
413            builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
414            builder.map_node(
415                fields.syntax().clone(),
416                ast.record_pat_field_list().unwrap().syntax().clone(),
417            );
418            builder.finish(&mut mapping);
419        }
420
421        ast
422    }
423
424    pub fn record_pat_field_list(
425        &self,
426        fields: impl IntoIterator<Item = ast::RecordPatField>,
427        rest_pat: Option<ast::RestPat>,
428    ) -> ast::RecordPatFieldList {
429        let (fields, input) = iterator_input(fields);
430        let ast = make::record_pat_field_list(fields, rest_pat.clone()).clone_for_update();
431
432        if let Some(mut mapping) = self.mappings() {
433            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
434            builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
435            if let Some(rest_pat) = rest_pat {
436                builder
437                    .map_node(rest_pat.syntax().clone(), ast.rest_pat().unwrap().syntax().clone());
438            }
439            builder.finish(&mut mapping);
440        }
441
442        ast
443    }
444
445    pub fn record_pat_field(&self, name_ref: ast::NameRef, pat: ast::Pat) -> ast::RecordPatField {
446        let ast = make::record_pat_field(name_ref.clone(), pat.clone()).clone_for_update();
447
448        if let Some(mut mapping) = self.mappings() {
449            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
450            builder.map_node(name_ref.syntax().clone(), ast.name_ref().unwrap().syntax().clone());
451            builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
452            builder.finish(&mut mapping);
453        }
454
455        ast
456    }
457
458    pub fn record_pat_field_shorthand(&self, pat: ast::Pat) -> ast::RecordPatField {
459        let ast = make::record_pat_field_shorthand(pat.clone()).clone_for_update();
460
461        if let Some(mut mapping) = self.mappings() {
462            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
463            builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
464            builder.finish(&mut mapping);
465        }
466
467        ast
468    }
469
470    pub fn path_pat(&self, path: ast::Path) -> ast::Pat {
471        let ast = make::path_pat(path.clone()).clone_for_update();
472
473        match &ast {
474            ast::Pat::PathPat(ast) => {
475                if let Some(mut mapping) = self.mappings() {
476                    let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
477                    builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
478                    builder.finish(&mut mapping)
479                }
480            }
481            ast::Pat::IdentPat(ast) => {
482                if let Some(mut mapping) = self.mappings() {
483                    let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
484                    builder.map_node(path.syntax().clone(), ast.name().unwrap().syntax().clone());
485                    builder.finish(&mut mapping)
486                }
487            }
488            _ => unreachable!(),
489        }
490
491        ast
492    }
493
494    pub fn rest_pat(&self) -> ast::RestPat {
495        make::rest_pat().clone_for_update()
496    }
497
498    pub fn or_pat(
499        &self,
500        pats: impl IntoIterator<Item = ast::Pat>,
501        leading_pipe: bool,
502    ) -> ast::OrPat {
503        let (pats, input) = iterator_input(pats);
504        let ast = make::or_pat(pats, leading_pipe).clone_for_update();
505
506        if let Some(mut mapping) = self.mappings() {
507            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
508            builder.map_children(input, ast.pats().map(|it| it.syntax().clone()));
509            builder.finish(&mut mapping);
510        }
511
512        ast
513    }
514
515    pub fn box_pat(&self, pat: ast::Pat) -> ast::BoxPat {
516        let ast = make::box_pat(pat.clone()).clone_for_update();
517
518        if let Some(mut mapping) = self.mappings() {
519            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
520            builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
521            builder.finish(&mut mapping);
522        }
523
524        ast
525    }
526
527    pub fn paren_pat(&self, pat: ast::Pat) -> ast::ParenPat {
528        let ast = make::paren_pat(pat.clone()).clone_for_update();
529
530        if let Some(mut mapping) = self.mappings() {
531            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
532            builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
533            builder.finish(&mut mapping);
534        }
535
536        ast
537    }
538
539    pub fn range_pat(&self, start: Option<ast::Pat>, end: Option<ast::Pat>) -> ast::RangePat {
540        let ast = make::range_pat(start.clone(), end.clone()).clone_for_update();
541
542        if let Some(mut mapping) = self.mappings() {
543            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
544            if let Some(start) = start {
545                builder.map_node(start.syntax().clone(), ast.start().unwrap().syntax().clone());
546            }
547            if let Some(end) = end {
548                builder.map_node(end.syntax().clone(), ast.end().unwrap().syntax().clone());
549            }
550            builder.finish(&mut mapping);
551        }
552
553        ast
554    }
555
556    pub fn ref_pat(&self, pat: ast::Pat) -> ast::RefPat {
557        let ast = make::ref_pat(pat.clone()).clone_for_update();
558
559        if let Some(mut mapping) = self.mappings() {
560            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
561            builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
562            builder.finish(&mut mapping);
563        }
564
565        ast
566    }
567
568    pub fn block_expr(
569        &self,
570        statements: impl IntoIterator<Item = ast::Stmt>,
571        tail_expr: Option<ast::Expr>,
572    ) -> ast::BlockExpr {
573        let (statements, mut input) = iterator_input(statements);
574
575        let ast = make::block_expr(statements, tail_expr.clone()).clone_for_update();
576
577        if let Some(mut mapping) = self.mappings() {
578            let stmt_list = ast.stmt_list().unwrap();
579            let mut builder = SyntaxMappingBuilder::new(stmt_list.syntax().clone());
580
581            if let Some(input) = tail_expr {
582                builder.map_node(
583                    input.syntax().clone(),
584                    stmt_list.tail_expr().unwrap().syntax().clone(),
585                );
586            } else if let Some(ast_tail) = stmt_list.tail_expr() {
587                // The parser interpreted the last statement (probably a statement with a block) as an Expr
588                let last_stmt = input.pop().unwrap();
589
590                builder.map_node(last_stmt, ast_tail.syntax().clone());
591            }
592
593            builder.map_children(input, stmt_list.statements().map(|it| it.syntax().clone()));
594
595            builder.finish(&mut mapping);
596        }
597
598        ast
599    }
600
601    pub fn expr_empty_block(&self) -> ast::BlockExpr {
602        make::expr_empty_block().clone_for_update()
603    }
604
605    pub fn expr_paren(&self, expr: ast::Expr) -> ast::ParenExpr {
606        let ast = make::expr_paren(expr.clone()).clone_for_update();
607
608        if let Some(mut mapping) = self.mappings() {
609            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
610            builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
611            builder.finish(&mut mapping);
612        }
613
614        ast
615    }
616
617    pub fn expr_tuple(&self, fields: impl IntoIterator<Item = ast::Expr>) -> ast::TupleExpr {
618        let (fields, input) = iterator_input(fields);
619        let ast = make::expr_tuple(fields).clone_for_update();
620
621        if let Some(mut mapping) = self.mappings() {
622            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
623            builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
624            builder.finish(&mut mapping);
625        }
626
627        ast
628    }
629
630    pub fn expr_assignment(&self, lhs: ast::Expr, rhs: ast::Expr) -> ast::BinExpr {
631        let ast = make::expr_assignment(lhs.clone(), rhs.clone()).clone_for_update();
632
633        if let Some(mut mapping) = self.mappings() {
634            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
635            builder.map_node(lhs.syntax().clone(), ast.lhs().unwrap().syntax().clone());
636            builder.map_node(rhs.syntax().clone(), ast.rhs().unwrap().syntax().clone());
637            builder.finish(&mut mapping);
638        }
639
640        ast
641    }
642
643    pub fn expr_bin(&self, lhs: ast::Expr, op: ast::BinaryOp, rhs: ast::Expr) -> ast::BinExpr {
644        let ast::Expr::BinExpr(ast) =
645            make::expr_bin_op(lhs.clone(), op, rhs.clone()).clone_for_update()
646        else {
647            unreachable!()
648        };
649
650        if let Some(mut mapping) = self.mappings() {
651            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
652            builder.map_node(lhs.syntax().clone(), ast.lhs().unwrap().syntax().clone());
653            builder.map_node(rhs.syntax().clone(), ast.rhs().unwrap().syntax().clone());
654            builder.finish(&mut mapping);
655        }
656
657        ast
658    }
659
660    pub fn expr_literal(&self, text: &str) -> ast::Literal {
661        make::expr_literal(text).clone_for_update()
662    }
663
664    pub fn expr_path(&self, path: ast::Path) -> ast::Expr {
665        let ast::Expr::PathExpr(ast) = make::expr_path(path.clone()).clone_for_update() else {
666            unreachable!()
667        };
668
669        if let Some(mut mapping) = self.mappings() {
670            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
671            builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
672            builder.finish(&mut mapping);
673        }
674
675        ast.into()
676    }
677
678    pub fn expr_prefix(&self, op: SyntaxKind, expr: ast::Expr) -> ast::PrefixExpr {
679        let ast = make::expr_prefix(op, expr.clone()).clone_for_update();
680
681        if let Some(mut mapping) = self.mappings() {
682            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
683            builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
684            builder.finish(&mut mapping);
685        }
686
687        ast
688    }
689
690    pub fn expr_call(&self, expr: ast::Expr, arg_list: ast::ArgList) -> ast::CallExpr {
691        let ast = make::expr_call(expr.clone(), arg_list.clone()).clone_for_update();
692
693        if let Some(mut mapping) = self.mappings() {
694            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
695            builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
696            builder.map_node(arg_list.syntax().clone(), ast.arg_list().unwrap().syntax().clone());
697            builder.finish(&mut mapping);
698        }
699
700        ast
701    }
702
703    pub fn expr_method_call(
704        &self,
705        receiver: ast::Expr,
706        method: ast::NameRef,
707        arg_list: ast::ArgList,
708    ) -> ast::MethodCallExpr {
709        let ast = make::expr_method_call(receiver.clone(), method.clone(), arg_list.clone())
710            .clone_for_update();
711
712        if let Some(mut mapping) = self.mappings() {
713            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
714            builder.map_node(receiver.syntax().clone(), ast.receiver().unwrap().syntax().clone());
715            builder.map_node(method.syntax().clone(), ast.name_ref().unwrap().syntax().clone());
716            builder.map_node(arg_list.syntax().clone(), ast.arg_list().unwrap().syntax().clone());
717            builder.finish(&mut mapping);
718        }
719
720        ast
721    }
722
723    pub fn arg_list(&self, args: impl IntoIterator<Item = ast::Expr>) -> ast::ArgList {
724        let (args, input) = iterator_input(args);
725        let ast = make::arg_list(args).clone_for_update();
726
727        if let Some(mut mapping) = self.mappings() {
728            let mut builder = SyntaxMappingBuilder::new(ast.syntax.clone());
729            builder.map_children(input, ast.args().map(|it| it.syntax().clone()));
730            builder.finish(&mut mapping);
731        }
732
733        ast
734    }
735
736    pub fn expr_ref(&self, expr: ast::Expr, exclusive: bool) -> ast::Expr {
737        let ast::Expr::RefExpr(ast) = make::expr_ref(expr.clone(), exclusive).clone_for_update()
738        else {
739            unreachable!()
740        };
741
742        if let Some(mut mapping) = self.mappings() {
743            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
744            builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
745            builder.finish(&mut mapping);
746        }
747
748        ast.into()
749    }
750
751    pub fn expr_closure(
752        &self,
753        pats: impl IntoIterator<Item = ast::Param>,
754        expr: ast::Expr,
755    ) -> ast::ClosureExpr {
756        let (args, input) = iterator_input(pats);
757        let ast = make::expr_closure(args, expr.clone()).clone_for_update();
758
759        if let Some(mut mapping) = self.mappings() {
760            let mut builder = SyntaxMappingBuilder::new(ast.syntax.clone());
761            builder.map_children(
762                input,
763                ast.param_list().unwrap().params().map(|param| param.syntax().clone()),
764            );
765            builder.map_node(expr.syntax().clone(), ast.body().unwrap().syntax().clone());
766            builder.finish(&mut mapping);
767        }
768
769        ast
770    }
771
772    pub fn expr_return(&self, expr: Option<ast::Expr>) -> ast::ReturnExpr {
773        let ast::Expr::ReturnExpr(ast) = make::expr_return(expr.clone()).clone_for_update() else {
774            unreachable!()
775        };
776
777        if let Some(mut mapping) = self.mappings() {
778            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
779            if let Some(input) = expr {
780                builder.map_node(input.syntax().clone(), ast.expr().unwrap().syntax().clone());
781            }
782            builder.finish(&mut mapping);
783        }
784
785        ast
786    }
787
788    pub fn expr_underscore(&self) -> ast::UnderscoreExpr {
789        let ast::Expr::UnderscoreExpr(ast) = make::ext::expr_underscore().clone_for_update() else {
790            unreachable!()
791        };
792
793        if let Some(mut mapping) = self.mappings() {
794            SyntaxMappingBuilder::new(ast.syntax().clone()).finish(&mut mapping);
795        }
796
797        ast
798    }
799
800    pub fn expr_if(
801        &self,
802        condition: ast::Expr,
803        then_branch: ast::BlockExpr,
804        else_branch: Option<ast::ElseBranch>,
805    ) -> ast::IfExpr {
806        let ast = make::expr_if(condition.clone(), then_branch.clone(), else_branch.clone())
807            .clone_for_update();
808
809        if let Some(mut mapping) = self.mappings() {
810            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
811            builder.map_node(condition.syntax().clone(), ast.condition().unwrap().syntax().clone());
812            builder.map_node(
813                then_branch.syntax().clone(),
814                ast.then_branch().unwrap().syntax().clone(),
815            );
816
817            if let Some(else_branch) = else_branch {
818                builder.map_node(
819                    else_branch.syntax().clone(),
820                    ast.else_branch().unwrap().syntax().clone(),
821                );
822            }
823            builder.finish(&mut mapping);
824        }
825
826        ast
827    }
828
829    pub fn expr_loop(&self, body: ast::BlockExpr) -> ast::LoopExpr {
830        let ast::Expr::LoopExpr(ast) = make::expr_loop(body.clone()).clone_for_update() else {
831            unreachable!()
832        };
833
834        if let Some(mut mapping) = self.mappings() {
835            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
836            builder.map_node(body.syntax().clone(), ast.loop_body().unwrap().syntax().clone());
837            builder.finish(&mut mapping);
838        }
839
840        ast
841    }
842
843    pub fn expr_while_loop(&self, condition: ast::Expr, body: ast::BlockExpr) -> ast::WhileExpr {
844        let ast = make::expr_while_loop(condition.clone(), body.clone()).clone_for_update();
845
846        if let Some(mut mapping) = self.mappings() {
847            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
848            builder.map_node(condition.syntax().clone(), ast.condition().unwrap().syntax().clone());
849            builder.map_node(body.syntax().clone(), ast.loop_body().unwrap().syntax().clone());
850            builder.finish(&mut mapping);
851        }
852
853        ast
854    }
855
856    pub fn expr_for_loop(
857        &self,
858        pat: ast::Pat,
859        iterable: ast::Expr,
860        body: ast::BlockExpr,
861    ) -> ast::ForExpr {
862        let ast =
863            make::expr_for_loop(pat.clone(), iterable.clone(), body.clone()).clone_for_update();
864
865        if let Some(mut mapping) = self.mappings() {
866            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
867            builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
868            builder.map_node(iterable.syntax().clone(), ast.iterable().unwrap().syntax().clone());
869            builder.map_node(body.syntax().clone(), ast.loop_body().unwrap().syntax().clone());
870            builder.finish(&mut mapping);
871        }
872
873        ast
874    }
875
876    pub fn expr_let(&self, pattern: ast::Pat, expr: ast::Expr) -> ast::LetExpr {
877        let ast = make::expr_let(pattern.clone(), expr.clone()).clone_for_update();
878
879        if let Some(mut mapping) = self.mappings() {
880            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
881            builder.map_node(pattern.syntax().clone(), ast.pat().unwrap().syntax().clone());
882            builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
883            builder.finish(&mut mapping);
884        }
885
886        ast
887    }
888
889    pub fn expr_stmt(&self, expr: ast::Expr) -> ast::ExprStmt {
890        let ast = make::expr_stmt(expr.clone()).clone_for_update();
891
892        if let Some(mut mapping) = self.mappings() {
893            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
894            builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
895            builder.finish(&mut mapping);
896        }
897
898        ast
899    }
900
901    pub fn expr_match(&self, expr: ast::Expr, match_arm_list: ast::MatchArmList) -> ast::MatchExpr {
902        let ast = make::expr_match(expr.clone(), match_arm_list.clone()).clone_for_update();
903
904        if let Some(mut mapping) = self.mappings() {
905            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
906            builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
907            builder.map_node(
908                match_arm_list.syntax().clone(),
909                ast.match_arm_list().unwrap().syntax().clone(),
910            );
911            builder.finish(&mut mapping);
912        }
913
914        ast
915    }
916
917    pub fn expr_macro(&self, path: ast::Path, tt: ast::TokenTree) -> ast::MacroExpr {
918        let ast = make::expr_macro(path.clone(), tt.clone()).clone_for_update();
919
920        if let Some(mut mapping) = self.mappings() {
921            let macro_call = ast.macro_call().unwrap();
922            let mut builder = SyntaxMappingBuilder::new(macro_call.syntax().clone());
923            builder.map_node(path.syntax().clone(), macro_call.path().unwrap().syntax().clone());
924            builder
925                .map_node(tt.syntax().clone(), macro_call.token_tree().unwrap().syntax().clone());
926            builder.finish(&mut mapping);
927        }
928
929        ast
930    }
931
932    pub fn match_arm(
933        &self,
934        pat: ast::Pat,
935        guard: Option<ast::MatchGuard>,
936        expr: ast::Expr,
937    ) -> ast::MatchArm {
938        let ast = make::match_arm(pat.clone(), guard.clone(), expr.clone()).clone_for_update();
939
940        if let Some(mut mapping) = self.mappings() {
941            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
942            builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
943            if let Some(guard) = guard {
944                builder.map_node(guard.syntax().clone(), ast.guard().unwrap().syntax().clone());
945            }
946            builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
947            builder.finish(&mut mapping);
948        }
949
950        ast
951    }
952
953    pub fn match_guard(&self, condition: ast::Expr) -> ast::MatchGuard {
954        let ast = make::match_guard(condition.clone()).clone_for_update();
955
956        if let Some(mut mapping) = self.mappings() {
957            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
958            builder.map_node(condition.syntax().clone(), ast.condition().unwrap().syntax().clone());
959            builder.finish(&mut mapping);
960        }
961
962        ast
963    }
964
965    pub fn match_arm_list(
966        &self,
967        match_arms: impl IntoIterator<Item = ast::MatchArm>,
968    ) -> ast::MatchArmList {
969        let (match_arms, input) = iterator_input(match_arms);
970        let ast = make::match_arm_list(match_arms).clone_for_update();
971
972        if let Some(mut mapping) = self.mappings() {
973            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
974            builder.map_children(input, ast.arms().map(|it| it.syntax().clone()));
975            builder.finish(&mut mapping);
976        }
977
978        ast
979    }
980
981    pub fn let_stmt(
982        &self,
983        pattern: ast::Pat,
984        ty: Option<ast::Type>,
985        initializer: Option<ast::Expr>,
986    ) -> ast::LetStmt {
987        let ast =
988            make::let_stmt(pattern.clone(), ty.clone(), initializer.clone()).clone_for_update();
989
990        if let Some(mut mapping) = self.mappings() {
991            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
992            builder.map_node(pattern.syntax().clone(), ast.pat().unwrap().syntax().clone());
993            if let Some(input) = ty {
994                builder.map_node(input.syntax().clone(), ast.ty().unwrap().syntax().clone());
995            }
996            if let Some(input) = initializer {
997                builder
998                    .map_node(input.syntax().clone(), ast.initializer().unwrap().syntax().clone());
999            }
1000            builder.finish(&mut mapping);
1001        }
1002
1003        ast
1004    }
1005
1006    pub fn let_else_stmt(
1007        &self,
1008        pattern: ast::Pat,
1009        ty: Option<ast::Type>,
1010        initializer: ast::Expr,
1011        diverging: ast::BlockExpr,
1012    ) -> ast::LetStmt {
1013        let ast = make::let_else_stmt(
1014            pattern.clone(),
1015            ty.clone(),
1016            initializer.clone(),
1017            diverging.clone(),
1018        )
1019        .clone_for_update();
1020
1021        if let Some(mut mapping) = self.mappings() {
1022            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1023            builder.map_node(pattern.syntax().clone(), ast.pat().unwrap().syntax().clone());
1024            if let Some(input) = ty {
1025                builder.map_node(input.syntax().clone(), ast.ty().unwrap().syntax().clone());
1026            }
1027            builder.map_node(
1028                initializer.syntax().clone(),
1029                ast.initializer().unwrap().syntax().clone(),
1030            );
1031            builder.map_node(diverging.syntax().clone(), ast.let_else().unwrap().syntax().clone());
1032            builder.finish(&mut mapping);
1033        }
1034
1035        ast
1036    }
1037
1038    pub fn type_arg(&self, ty: ast::Type) -> ast::TypeArg {
1039        let ast = make::type_arg(ty.clone()).clone_for_update();
1040
1041        if let Some(mut mapping) = self.mappings() {
1042            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1043            builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
1044            builder.finish(&mut mapping);
1045        }
1046
1047        ast
1048    }
1049
1050    pub fn lifetime_arg(&self, lifetime: ast::Lifetime) -> ast::LifetimeArg {
1051        let ast = make::lifetime_arg(lifetime.clone()).clone_for_update();
1052
1053        if let Some(mut mapping) = self.mappings() {
1054            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1055            builder.map_node(lifetime.syntax().clone(), ast.lifetime().unwrap().syntax().clone());
1056            builder.finish(&mut mapping);
1057        }
1058
1059        ast
1060    }
1061
1062    pub fn item_const(
1063        &self,
1064        attrs: impl IntoIterator<Item = ast::Attr>,
1065        visibility: Option<ast::Visibility>,
1066        name: ast::Name,
1067        ty: ast::Type,
1068        expr: ast::Expr,
1069    ) -> ast::Const {
1070        let (attrs, attrs_input) = iterator_input(attrs);
1071        let ast =
1072            make::item_const(attrs, visibility.clone(), name.clone(), ty.clone(), expr.clone())
1073                .clone_for_update();
1074
1075        if let Some(mut mapping) = self.mappings() {
1076            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1077            builder.map_children(attrs_input, ast.attrs().map(|attr| attr.syntax().clone()));
1078            if let Some(visibility) = visibility {
1079                builder.map_node(
1080                    visibility.syntax().clone(),
1081                    ast.visibility().unwrap().syntax().clone(),
1082                );
1083            }
1084            builder.map_node(name.syntax().clone(), ast.name().unwrap().syntax().clone());
1085            builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
1086            builder.map_node(expr.syntax().clone(), ast.body().unwrap().syntax().clone());
1087            builder.finish(&mut mapping);
1088        }
1089
1090        ast
1091    }
1092
1093    pub fn item_static(
1094        &self,
1095        visibility: Option<ast::Visibility>,
1096        is_unsafe: bool,
1097        is_mut: bool,
1098        name: ast::Name,
1099        ty: ast::Type,
1100        expr: Option<ast::Expr>,
1101    ) -> ast::Static {
1102        let ast = make::item_static(
1103            visibility.clone(),
1104            is_unsafe,
1105            is_mut,
1106            name.clone(),
1107            ty.clone(),
1108            expr.clone(),
1109        )
1110        .clone_for_update();
1111
1112        if let Some(mut mapping) = self.mappings() {
1113            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1114            if let Some(visibility) = visibility {
1115                builder.map_node(
1116                    visibility.syntax().clone(),
1117                    ast.visibility().unwrap().syntax().clone(),
1118                );
1119            }
1120
1121            builder.map_node(name.syntax().clone(), ast.name().unwrap().syntax().clone());
1122            builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
1123
1124            if let Some(expr) = expr {
1125                builder.map_node(expr.syntax().clone(), ast.body().unwrap().syntax().clone());
1126            }
1127            builder.finish(&mut mapping);
1128        }
1129
1130        ast
1131    }
1132
1133    pub fn param(&self, pat: ast::Pat, ty: ast::Type) -> ast::Param {
1134        let ast = make::param(pat.clone(), ty.clone());
1135
1136        if let Some(mut mapping) = self.mappings() {
1137            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1138            builder.map_node(pat.syntax().clone(), ast.pat().unwrap().syntax().clone());
1139            builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
1140            builder.finish(&mut mapping);
1141        }
1142
1143        ast
1144    }
1145
1146    pub fn generic_arg_list(
1147        &self,
1148        generic_args: impl IntoIterator<Item = ast::GenericArg>,
1149        is_turbo: bool,
1150    ) -> ast::GenericArgList {
1151        let (generic_args, input) = iterator_input(generic_args);
1152        let ast = if is_turbo {
1153            make::turbofish_generic_arg_list(generic_args).clone_for_update()
1154        } else {
1155            make::generic_arg_list(generic_args).clone_for_update()
1156        };
1157
1158        if let Some(mut mapping) = self.mappings() {
1159            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1160            builder.map_children(input, ast.generic_args().map(|arg| arg.syntax().clone()));
1161            builder.finish(&mut mapping);
1162        }
1163
1164        ast
1165    }
1166
1167    pub fn record_expr(
1168        &self,
1169        path: ast::Path,
1170        fields: ast::RecordExprFieldList,
1171    ) -> ast::RecordExpr {
1172        let ast = make::record_expr(path.clone(), fields.clone()).clone_for_update();
1173        if let Some(mut mapping) = self.mappings() {
1174            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1175            builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
1176            builder.map_node(
1177                fields.syntax().clone(),
1178                ast.record_expr_field_list().unwrap().syntax().clone(),
1179            );
1180            builder.finish(&mut mapping);
1181        }
1182        ast
1183    }
1184
1185    pub fn record_expr_field(
1186        &self,
1187        name: ast::NameRef,
1188        expr: Option<ast::Expr>,
1189    ) -> ast::RecordExprField {
1190        let ast = make::record_expr_field(name.clone(), expr.clone()).clone_for_update();
1191
1192        if let Some(mut mapping) = self.mappings() {
1193            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1194
1195            builder.map_node(name.syntax().clone(), ast.name_ref().unwrap().syntax().clone());
1196            if let Some(expr) = expr {
1197                builder.map_node(expr.syntax().clone(), ast.expr().unwrap().syntax().clone());
1198            }
1199
1200            builder.finish(&mut mapping);
1201        }
1202
1203        ast
1204    }
1205
1206    pub fn record_field_list(
1207        &self,
1208        fields: impl IntoIterator<Item = ast::RecordField>,
1209    ) -> ast::RecordFieldList {
1210        let (fields, input) = iterator_input(fields);
1211        let ast = make::record_field_list(fields).clone_for_update();
1212
1213        if let Some(mut mapping) = self.mappings() {
1214            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1215
1216            builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
1217
1218            builder.finish(&mut mapping);
1219        }
1220
1221        ast
1222    }
1223
1224    pub fn record_field(
1225        &self,
1226        visibility: Option<ast::Visibility>,
1227        name: ast::Name,
1228        ty: ast::Type,
1229    ) -> ast::RecordField {
1230        let ast =
1231            make::record_field(visibility.clone(), name.clone(), ty.clone()).clone_for_update();
1232
1233        if let Some(mut mapping) = self.mappings() {
1234            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1235            if let Some(visibility) = visibility {
1236                builder.map_node(
1237                    visibility.syntax().clone(),
1238                    ast.visibility().unwrap().syntax().clone(),
1239                );
1240            }
1241
1242            builder.map_node(name.syntax().clone(), ast.name().unwrap().syntax().clone());
1243            builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
1244
1245            builder.finish(&mut mapping);
1246        }
1247
1248        ast
1249    }
1250
1251    pub fn tuple_field_list(
1252        &self,
1253        fields: impl IntoIterator<Item = ast::TupleField>,
1254    ) -> ast::TupleFieldList {
1255        let (fields, input) = iterator_input(fields);
1256        let ast = make::tuple_field_list(fields).clone_for_update();
1257
1258        if let Some(mut mapping) = self.mappings() {
1259            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1260
1261            builder.map_children(input, ast.fields().map(|it| it.syntax().clone()));
1262
1263            builder.finish(&mut mapping);
1264        }
1265
1266        ast
1267    }
1268
1269    pub fn tuple_field(
1270        &self,
1271        visibility: Option<ast::Visibility>,
1272        ty: ast::Type,
1273    ) -> ast::TupleField {
1274        let ast = make::tuple_field(visibility.clone(), ty.clone()).clone_for_update();
1275
1276        if let Some(mut mapping) = self.mappings() {
1277            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1278            if let Some(visibility) = visibility {
1279                builder.map_node(
1280                    visibility.syntax().clone(),
1281                    ast.visibility().unwrap().syntax().clone(),
1282                );
1283            }
1284
1285            builder.map_node(ty.syntax().clone(), ast.ty().unwrap().syntax().clone());
1286
1287            builder.finish(&mut mapping);
1288        }
1289
1290        ast
1291    }
1292
1293    pub fn item_enum(
1294        &self,
1295        attrs: impl IntoIterator<Item = ast::Attr>,
1296        visibility: Option<ast::Visibility>,
1297        name: ast::Name,
1298        generic_param_list: Option<ast::GenericParamList>,
1299        where_clause: Option<ast::WhereClause>,
1300        variant_list: ast::VariantList,
1301    ) -> ast::Enum {
1302        let ast = make::enum_(
1303            attrs,
1304            visibility.clone(),
1305            name.clone(),
1306            generic_param_list.clone(),
1307            where_clause.clone(),
1308            variant_list.clone(),
1309        )
1310        .clone_for_update();
1311
1312        if let Some(mut mapping) = self.mappings() {
1313            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1314            if let Some(visibility) = visibility {
1315                builder.map_node(
1316                    visibility.syntax().clone(),
1317                    ast.visibility().unwrap().syntax().clone(),
1318                );
1319            }
1320
1321            builder.map_node(name.syntax().clone(), ast.name().unwrap().syntax().clone());
1322
1323            if let Some(generic_param_list) = generic_param_list {
1324                builder.map_node(
1325                    generic_param_list.syntax().clone(),
1326                    ast.generic_param_list().unwrap().syntax().clone(),
1327                );
1328            }
1329
1330            if let Some(where_clause) = where_clause {
1331                builder.map_node(
1332                    where_clause.syntax().clone(),
1333                    ast.where_clause().unwrap().syntax().clone(),
1334                );
1335            }
1336
1337            builder.map_node(
1338                variant_list.syntax().clone(),
1339                ast.variant_list().unwrap().syntax().clone(),
1340            );
1341
1342            builder.finish(&mut mapping);
1343        }
1344
1345        ast
1346    }
1347
1348    pub fn variant_list(
1349        &self,
1350        variants: impl IntoIterator<Item = ast::Variant>,
1351    ) -> ast::VariantList {
1352        let (variants, input) = iterator_input(variants);
1353        let ast = make::variant_list(variants).clone_for_update();
1354
1355        if let Some(mut mapping) = self.mappings() {
1356            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1357
1358            builder.map_children(input, ast.variants().map(|it| it.syntax().clone()));
1359
1360            builder.finish(&mut mapping);
1361        }
1362
1363        ast
1364    }
1365
1366    pub fn variant(
1367        &self,
1368        visibility: Option<ast::Visibility>,
1369        name: ast::Name,
1370        field_list: Option<ast::FieldList>,
1371        discriminant: Option<ast::Expr>,
1372    ) -> ast::Variant {
1373        let ast = make::variant(
1374            visibility.clone(),
1375            name.clone(),
1376            field_list.clone(),
1377            discriminant.clone(),
1378        )
1379        .clone_for_update();
1380
1381        if let Some(mut mapping) = self.mappings() {
1382            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1383            if let Some(visibility) = visibility {
1384                builder.map_node(
1385                    visibility.syntax().clone(),
1386                    ast.visibility().unwrap().syntax().clone(),
1387                );
1388            }
1389
1390            builder.map_node(name.syntax().clone(), ast.name().unwrap().syntax().clone());
1391
1392            if let Some(field_list) = field_list {
1393                builder.map_node(
1394                    field_list.syntax().clone(),
1395                    ast.field_list().unwrap().syntax().clone(),
1396                );
1397            }
1398
1399            if let Some(discriminant) = discriminant {
1400                builder
1401                    .map_node(discriminant.syntax().clone(), ast.expr().unwrap().syntax().clone());
1402            }
1403
1404            builder.finish(&mut mapping);
1405        }
1406
1407        ast
1408    }
1409
1410    pub fn fn_(
1411        &self,
1412        attrs: impl IntoIterator<Item = ast::Attr>,
1413        visibility: Option<ast::Visibility>,
1414        fn_name: ast::Name,
1415        type_params: Option<ast::GenericParamList>,
1416        where_clause: Option<ast::WhereClause>,
1417        params: ast::ParamList,
1418        body: ast::BlockExpr,
1419        ret_type: Option<ast::RetType>,
1420        is_async: bool,
1421        is_const: bool,
1422        is_unsafe: bool,
1423        is_gen: bool,
1424    ) -> ast::Fn {
1425        let (attrs, input) = iterator_input(attrs);
1426        let ast = make::fn_(
1427            attrs,
1428            visibility.clone(),
1429            fn_name.clone(),
1430            type_params.clone(),
1431            where_clause.clone(),
1432            params.clone(),
1433            body.clone(),
1434            ret_type.clone(),
1435            is_async,
1436            is_const,
1437            is_unsafe,
1438            is_gen,
1439        );
1440
1441        if let Some(mut mapping) = self.mappings() {
1442            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1443            builder.map_children(input, ast.attrs().map(|attr| attr.syntax().clone()));
1444
1445            if let Some(visibility) = visibility {
1446                builder.map_node(
1447                    visibility.syntax().clone(),
1448                    ast.visibility().unwrap().syntax().clone(),
1449                );
1450            }
1451            builder.map_node(fn_name.syntax().clone(), ast.name().unwrap().syntax().clone());
1452            if let Some(type_params) = type_params {
1453                builder.map_node(
1454                    type_params.syntax().clone(),
1455                    ast.generic_param_list().unwrap().syntax().clone(),
1456                );
1457            }
1458            if let Some(where_clause) = where_clause {
1459                builder.map_node(
1460                    where_clause.syntax().clone(),
1461                    ast.where_clause().unwrap().syntax().clone(),
1462                );
1463            }
1464            builder.map_node(params.syntax().clone(), ast.param_list().unwrap().syntax().clone());
1465            builder.map_node(body.syntax().clone(), ast.body().unwrap().syntax().clone());
1466            if let Some(ret_type) = ret_type {
1467                builder
1468                    .map_node(ret_type.syntax().clone(), ast.ret_type().unwrap().syntax().clone());
1469            }
1470
1471            builder.finish(&mut mapping);
1472        }
1473
1474        ast
1475    }
1476
1477    pub fn assoc_item_list(
1478        &self,
1479        items: impl IntoIterator<Item = ast::AssocItem>,
1480    ) -> ast::AssocItemList {
1481        let (items, input) = iterator_input(items);
1482        let items_vec: Vec<_> = items.into_iter().collect();
1483        let ast = make::assoc_item_list(Some(items_vec)).clone_for_update();
1484
1485        if let Some(mut mapping) = self.mappings() {
1486            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1487            builder.map_children(input, ast.assoc_items().map(|item| item.syntax().clone()));
1488            builder.finish(&mut mapping);
1489        }
1490
1491        ast
1492    }
1493
1494    pub fn attr_outer(&self, meta: ast::Meta) -> ast::Attr {
1495        let ast = make::attr_outer(meta.clone()).clone_for_update();
1496
1497        if let Some(mut mapping) = self.mappings() {
1498            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1499            builder.map_node(meta.syntax().clone(), ast.meta().unwrap().syntax().clone());
1500            builder.finish(&mut mapping);
1501        }
1502
1503        ast
1504    }
1505
1506    pub fn attr_inner(&self, meta: ast::Meta) -> ast::Attr {
1507        let ast = make::attr_inner(meta.clone()).clone_for_update();
1508
1509        if let Some(mut mapping) = self.mappings() {
1510            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1511            builder.map_node(meta.syntax().clone(), ast.meta().unwrap().syntax().clone());
1512            builder.finish(&mut mapping);
1513        }
1514
1515        ast
1516    }
1517
1518    pub fn meta_token_tree(&self, path: ast::Path, tt: ast::TokenTree) -> ast::Meta {
1519        let ast = make::meta_token_tree(path.clone(), tt.clone()).clone_for_update();
1520
1521        if let Some(mut mapping) = self.mappings() {
1522            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1523            builder.map_node(path.syntax().clone(), ast.path().unwrap().syntax().clone());
1524            builder.map_node(tt.syntax().clone(), ast.token_tree().unwrap().syntax().clone());
1525            builder.finish(&mut mapping);
1526        }
1527
1528        ast
1529    }
1530
1531    pub fn token_tree(
1532        &self,
1533        delimiter: SyntaxKind,
1534        tt: impl IntoIterator<Item = NodeOrToken<ast::TokenTree, SyntaxToken>>,
1535    ) -> ast::TokenTree {
1536        let tt: Vec<_> = tt.into_iter().collect();
1537        let input: Vec<_> = tt.iter().cloned().filter_map(only_nodes).collect();
1538
1539        let ast = make::token_tree(delimiter, tt).clone_for_update();
1540
1541        if let Some(mut mapping) = self.mappings() {
1542            let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
1543            builder.map_children(input, ast.token_trees_and_tokens().filter_map(only_nodes));
1544            builder.finish(&mut mapping);
1545        }
1546
1547        return ast;
1548
1549        fn only_nodes(element: NodeOrToken<ast::TokenTree, SyntaxToken>) -> Option<SyntaxNode> {
1550            element.as_node().map(|it| it.syntax().clone())
1551        }
1552    }
1553
1554    pub fn token(&self, kind: SyntaxKind) -> SyntaxToken {
1555        make::token(kind)
1556    }
1557
1558    pub fn whitespace(&self, text: &str) -> SyntaxToken {
1559        make::tokens::whitespace(text)
1560    }
1561
1562    pub fn ident(&self, text: &str) -> SyntaxToken {
1563        make::tokens::ident(text)
1564    }
1565}
1566
1567// `ext` constructors
1568impl SyntaxFactory {
1569    pub fn ident_path(&self, ident: &str) -> ast::Path {
1570        self.path_unqualified(self.path_segment(self.name_ref(ident)))
1571    }
1572
1573    pub fn expr_unit(&self) -> ast::Expr {
1574        self.expr_tuple([]).into()
1575    }
1576
1577    pub fn ty_option(&self, t: ast::Type) -> ast::PathType {
1578        let generic_arg_list = self.generic_arg_list([self.type_arg(t).into()], false);
1579        let path = self.path_unqualified(
1580            self.path_segment_generics(self.name_ref("Option"), generic_arg_list),
1581        );
1582
1583        self.ty_path(path)
1584    }
1585
1586    pub fn ty_result(&self, t: ast::Type, e: ast::Type) -> ast::PathType {
1587        let generic_arg_list =
1588            self.generic_arg_list([self.type_arg(t).into(), self.type_arg(e).into()], false);
1589        let path = self.path_unqualified(
1590            self.path_segment_generics(self.name_ref("Result"), generic_arg_list),
1591        );
1592
1593        self.ty_path(path)
1594    }
1595}
1596
1597// We need to collect `input` here instead of taking `impl IntoIterator + Clone`,
1598// because if we took `impl IntoIterator + Clone`, that could be something like an
1599// `Iterator::map` with a closure that also makes use of a `SyntaxFactory` constructor.
1600//
1601// In that case, the iterator would be evaluated inside of the call to `map_children`,
1602// and the inner constructor would try to take a mutable borrow of the mappings `RefCell`,
1603// which would panic since it's already being mutably borrowed in the outer constructor.
1604fn iterator_input<N: AstNode>(input: impl IntoIterator<Item = N>) -> (Vec<N>, Vec<SyntaxNode>) {
1605    input
1606        .into_iter()
1607        .map(|it| {
1608            let syntax = it.syntax().clone();
1609            (it, syntax)
1610        })
1611        .collect()
1612}
syntax/ast/syntax_factory/constructors.rs

syntax/ast/syntax_factory/
constructors.rs
