1use rustc_ast::ptr::P;
2use rustc_ast::token::Delimiter;
3use rustc_ast::tokenstream::TokenStream;
4use rustc_ast::util::literal;
5use rustc_ast::{
6 self as ast, AnonConst, AttrVec, BlockCheckMode, Expr, LocalKind, MatchKind, PatKind, UnOp,
7 attr, token, tokenstream,
8};
9use rustc_span::source_map::Spanned;
10use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
11use thin_vec::{ThinVec, thin_vec};
12
13use crate::base::ExtCtxt;
14
15impl<'a> ExtCtxt<'a> {
16 pub fn path(&self, span: Span, strs: Vec<Ident>) -> ast::Path {
17 self.path_all(span, false, strs, vec![])
18 }
19 pub fn path_ident(&self, span: Span, id: Ident) -> ast::Path {
20 self.path(span, vec![id])
21 }
22 pub fn path_global(&self, span: Span, strs: Vec<Ident>) -> ast::Path {
23 self.path_all(span, true, strs, vec![])
24 }
25 pub fn path_all(
26 &self,
27 span: Span,
28 global: bool,
29 mut idents: Vec<Ident>,
30 args: Vec<ast::GenericArg>,
31 ) -> ast::Path {
32 assert!(!idents.is_empty());
33 let add_root = global && !idents[0].is_path_segment_keyword();
34 let mut segments = ThinVec::with_capacity(idents.len() + add_root as usize);
35 if add_root {
36 segments.push(ast::PathSegment::path_root(span));
37 }
38 let last_ident = idents.pop().unwrap();
39 segments.extend(
40 idents.into_iter().map(|ident| ast::PathSegment::from_ident(ident.with_span_pos(span))),
41 );
42 let args = if !args.is_empty() {
43 let args = args.into_iter().map(ast::AngleBracketedArg::Arg).collect();
44 Some(ast::AngleBracketedArgs { args, span }.into())
45 } else {
46 None
47 };
48 segments.push(ast::PathSegment {
49 ident: last_ident.with_span_pos(span),
50 id: ast::DUMMY_NODE_ID,
51 args,
52 });
53 ast::Path { span, segments, tokens: None }
54 }
55
56 pub fn macro_call(
57 &self,
58 span: Span,
59 path: ast::Path,
60 delim: Delimiter,
61 tokens: TokenStream,
62 ) -> P<ast::MacCall> {
63 P(ast::MacCall {
64 path,
65 args: P(ast::DelimArgs {
66 dspan: tokenstream::DelimSpan { open: span, close: span },
67 delim,
68 tokens,
69 }),
70 })
71 }
72
73 pub fn ty_mt(&self, ty: P<ast::Ty>, mutbl: ast::Mutability) -> ast::MutTy {
74 ast::MutTy { ty, mutbl }
75 }
76
77 pub fn ty(&self, span: Span, kind: ast::TyKind) -> P<ast::Ty> {
78 P(ast::Ty { id: ast::DUMMY_NODE_ID, span, kind, tokens: None })
79 }
80
81 pub fn ty_infer(&self, span: Span) -> P<ast::Ty> {
82 self.ty(span, ast::TyKind::Infer)
83 }
84
85 pub fn ty_path(&self, path: ast::Path) -> P<ast::Ty> {
86 self.ty(path.span, ast::TyKind::Path(None, path))
87 }
88
89 pub fn ty_ident(&self, span: Span, ident: Ident) -> P<ast::Ty> {
92 self.ty_path(self.path_ident(span, ident))
93 }
94
95 pub fn anon_const(&self, span: Span, kind: ast::ExprKind) -> ast::AnonConst {
96 ast::AnonConst {
97 id: ast::DUMMY_NODE_ID,
98 value: P(ast::Expr {
99 id: ast::DUMMY_NODE_ID,
100 kind,
101 span,
102 attrs: AttrVec::new(),
103 tokens: None,
104 }),
105 }
106 }
107
108 pub fn const_ident(&self, span: Span, ident: Ident) -> ast::AnonConst {
109 self.anon_const(span, ast::ExprKind::Path(None, self.path_ident(span, ident)))
110 }
111
112 pub fn ty_ref(
113 &self,
114 span: Span,
115 ty: P<ast::Ty>,
116 lifetime: Option<ast::Lifetime>,
117 mutbl: ast::Mutability,
118 ) -> P<ast::Ty> {
119 self.ty(span, ast::TyKind::Ref(lifetime, self.ty_mt(ty, mutbl)))
120 }
121
122 pub fn ty_ptr(&self, span: Span, ty: P<ast::Ty>, mutbl: ast::Mutability) -> P<ast::Ty> {
123 self.ty(span, ast::TyKind::Ptr(self.ty_mt(ty, mutbl)))
124 }
125
126 pub fn typaram(
127 &self,
128 span: Span,
129 ident: Ident,
130 bounds: ast::GenericBounds,
131 default: Option<P<ast::Ty>>,
132 ) -> ast::GenericParam {
133 ast::GenericParam {
134 ident: ident.with_span_pos(span),
135 id: ast::DUMMY_NODE_ID,
136 attrs: AttrVec::new(),
137 bounds,
138 kind: ast::GenericParamKind::Type { default },
139 is_placeholder: false,
140 colon_span: None,
141 }
142 }
143
144 pub fn lifetime_param(
145 &self,
146 span: Span,
147 ident: Ident,
148 bounds: ast::GenericBounds,
149 ) -> ast::GenericParam {
150 ast::GenericParam {
151 id: ast::DUMMY_NODE_ID,
152 ident: ident.with_span_pos(span),
153 attrs: AttrVec::new(),
154 bounds,
155 is_placeholder: false,
156 kind: ast::GenericParamKind::Lifetime,
157 colon_span: None,
158 }
159 }
160
161 pub fn const_param(
162 &self,
163 span: Span,
164 ident: Ident,
165 bounds: ast::GenericBounds,
166 ty: P<ast::Ty>,
167 default: Option<AnonConst>,
168 ) -> ast::GenericParam {
169 ast::GenericParam {
170 id: ast::DUMMY_NODE_ID,
171 ident: ident.with_span_pos(span),
172 attrs: AttrVec::new(),
173 bounds,
174 is_placeholder: false,
175 kind: ast::GenericParamKind::Const { ty, span: DUMMY_SP, default },
176 colon_span: None,
177 }
178 }
179
180 pub fn trait_ref(&self, path: ast::Path) -> ast::TraitRef {
181 ast::TraitRef { path, ref_id: ast::DUMMY_NODE_ID }
182 }
183
184 pub fn poly_trait_ref(&self, span: Span, path: ast::Path, is_const: bool) -> ast::PolyTraitRef {
185 ast::PolyTraitRef {
186 bound_generic_params: ThinVec::new(),
187 modifiers: ast::TraitBoundModifiers {
188 polarity: ast::BoundPolarity::Positive,
189 constness: if is_const {
190 ast::BoundConstness::Maybe(DUMMY_SP)
191 } else {
192 ast::BoundConstness::Never
193 },
194 asyncness: ast::BoundAsyncness::Normal,
195 },
196 trait_ref: self.trait_ref(path),
197 span,
198 parens: ast::Parens::No,
199 }
200 }
201
202 pub fn trait_bound(&self, path: ast::Path, is_const: bool) -> ast::GenericBound {
203 ast::GenericBound::Trait(self.poly_trait_ref(path.span, path, is_const))
204 }
205
206 pub fn lifetime(&self, span: Span, ident: Ident) -> ast::Lifetime {
207 ast::Lifetime { id: ast::DUMMY_NODE_ID, ident: ident.with_span_pos(span) }
208 }
209
210 pub fn lifetime_static(&self, span: Span) -> ast::Lifetime {
211 self.lifetime(span, Ident::new(kw::StaticLifetime, span))
212 }
213
214 pub fn stmt_expr(&self, expr: P<ast::Expr>) -> ast::Stmt {
215 ast::Stmt { id: ast::DUMMY_NODE_ID, span: expr.span, kind: ast::StmtKind::Expr(expr) }
216 }
217
218 pub fn stmt_let(&self, sp: Span, mutbl: bool, ident: Ident, ex: P<ast::Expr>) -> ast::Stmt {
219 self.stmt_let_ty(sp, mutbl, ident, None, ex)
220 }
221
222 pub fn stmt_let_ty(
223 &self,
224 sp: Span,
225 mutbl: bool,
226 ident: Ident,
227 ty: Option<P<ast::Ty>>,
228 ex: P<ast::Expr>,
229 ) -> ast::Stmt {
230 let pat = if mutbl {
231 self.pat_ident_binding_mode(sp, ident, ast::BindingMode::MUT)
232 } else {
233 self.pat_ident(sp, ident)
234 };
235 let local = P(ast::Local {
236 super_: None,
237 pat,
238 ty,
239 id: ast::DUMMY_NODE_ID,
240 kind: LocalKind::Init(ex),
241 span: sp,
242 colon_sp: None,
243 attrs: AttrVec::new(),
244 tokens: None,
245 });
246 self.stmt_local(local, sp)
247 }
248
249 pub fn stmt_let_type_only(&self, span: Span, ty: P<ast::Ty>) -> ast::Stmt {
251 let local = P(ast::Local {
252 super_: None,
253 pat: self.pat_wild(span),
254 ty: Some(ty),
255 id: ast::DUMMY_NODE_ID,
256 kind: LocalKind::Decl,
257 span,
258 colon_sp: None,
259 attrs: AttrVec::new(),
260 tokens: None,
261 });
262 self.stmt_local(local, span)
263 }
264
265 pub fn stmt_semi(&self, expr: P<ast::Expr>) -> ast::Stmt {
266 ast::Stmt { id: ast::DUMMY_NODE_ID, span: expr.span, kind: ast::StmtKind::Semi(expr) }
267 }
268
269 pub fn stmt_local(&self, local: P<ast::Local>, span: Span) -> ast::Stmt {
270 ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Let(local), span }
271 }
272
273 pub fn stmt_item(&self, sp: Span, item: P<ast::Item>) -> ast::Stmt {
274 ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Item(item), span: sp }
275 }
276
277 pub fn block_expr(&self, expr: P<ast::Expr>) -> P<ast::Block> {
278 self.block(
279 expr.span,
280 thin_vec![ast::Stmt {
281 id: ast::DUMMY_NODE_ID,
282 span: expr.span,
283 kind: ast::StmtKind::Expr(expr),
284 }],
285 )
286 }
287 pub fn block(&self, span: Span, stmts: ThinVec<ast::Stmt>) -> P<ast::Block> {
288 P(ast::Block {
289 stmts,
290 id: ast::DUMMY_NODE_ID,
291 rules: BlockCheckMode::Default,
292 span,
293 tokens: None,
294 })
295 }
296
297 pub fn expr(&self, span: Span, kind: ast::ExprKind) -> P<ast::Expr> {
298 P(ast::Expr { id: ast::DUMMY_NODE_ID, kind, span, attrs: AttrVec::new(), tokens: None })
299 }
300
301 pub fn expr_path(&self, path: ast::Path) -> P<ast::Expr> {
302 self.expr(path.span, ast::ExprKind::Path(None, path))
303 }
304
305 pub fn expr_ident(&self, span: Span, id: Ident) -> P<ast::Expr> {
306 self.expr_path(self.path_ident(span, id))
307 }
308 pub fn expr_self(&self, span: Span) -> P<ast::Expr> {
309 self.expr_ident(span, Ident::with_dummy_span(kw::SelfLower))
310 }
311
312 pub fn expr_macro_call(&self, span: Span, call: P<ast::MacCall>) -> P<ast::Expr> {
313 self.expr(span, ast::ExprKind::MacCall(call))
314 }
315
316 pub fn expr_binary(
317 &self,
318 sp: Span,
319 op: ast::BinOpKind,
320 lhs: P<ast::Expr>,
321 rhs: P<ast::Expr>,
322 ) -> P<ast::Expr> {
323 self.expr(sp, ast::ExprKind::Binary(Spanned { node: op, span: sp }, lhs, rhs))
324 }
325
326 pub fn expr_deref(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
327 self.expr(sp, ast::ExprKind::Unary(UnOp::Deref, e))
328 }
329
330 pub fn expr_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
331 self.expr(sp, ast::ExprKind::AddrOf(ast::BorrowKind::Ref, ast::Mutability::Not, e))
332 }
333
334 pub fn expr_paren(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
335 self.expr(sp, ast::ExprKind::Paren(e))
336 }
337
338 pub fn expr_method_call(
339 &self,
340 span: Span,
341 expr: P<ast::Expr>,
342 ident: Ident,
343 args: ThinVec<P<ast::Expr>>,
344 ) -> P<ast::Expr> {
345 let seg = ast::PathSegment::from_ident(ident);
346 self.expr(
347 span,
348 ast::ExprKind::MethodCall(Box::new(ast::MethodCall {
349 seg,
350 receiver: expr,
351 args,
352 span,
353 })),
354 )
355 }
356
357 pub fn expr_call(
358 &self,
359 span: Span,
360 expr: P<ast::Expr>,
361 args: ThinVec<P<ast::Expr>>,
362 ) -> P<ast::Expr> {
363 self.expr(span, ast::ExprKind::Call(expr, args))
364 }
365 pub fn expr_loop(&self, sp: Span, block: P<ast::Block>) -> P<ast::Expr> {
366 self.expr(sp, ast::ExprKind::Loop(block, None, sp))
367 }
368 pub fn expr_asm(&self, sp: Span, expr: P<ast::InlineAsm>) -> P<ast::Expr> {
369 self.expr(sp, ast::ExprKind::InlineAsm(expr))
370 }
371 pub fn expr_call_ident(
372 &self,
373 span: Span,
374 id: Ident,
375 args: ThinVec<P<ast::Expr>>,
376 ) -> P<ast::Expr> {
377 self.expr(span, ast::ExprKind::Call(self.expr_ident(span, id), args))
378 }
379 pub fn expr_call_global(
380 &self,
381 sp: Span,
382 fn_path: Vec<Ident>,
383 args: ThinVec<P<ast::Expr>>,
384 ) -> P<ast::Expr> {
385 let pathexpr = self.expr_path(self.path_global(sp, fn_path));
386 self.expr_call(sp, pathexpr, args)
387 }
388 pub fn expr_block(&self, b: P<ast::Block>) -> P<ast::Expr> {
389 self.expr(b.span, ast::ExprKind::Block(b, None))
390 }
391 pub fn field_imm(&self, span: Span, ident: Ident, e: P<ast::Expr>) -> ast::ExprField {
392 ast::ExprField {
393 ident: ident.with_span_pos(span),
394 expr: e,
395 span,
396 is_shorthand: false,
397 attrs: AttrVec::new(),
398 id: ast::DUMMY_NODE_ID,
399 is_placeholder: false,
400 }
401 }
402 pub fn expr_struct(
403 &self,
404 span: Span,
405 path: ast::Path,
406 fields: ThinVec<ast::ExprField>,
407 ) -> P<ast::Expr> {
408 self.expr(
409 span,
410 ast::ExprKind::Struct(P(ast::StructExpr {
411 qself: None,
412 path,
413 fields,
414 rest: ast::StructRest::None,
415 })),
416 )
417 }
418 pub fn expr_struct_ident(
419 &self,
420 span: Span,
421 id: Ident,
422 fields: ThinVec<ast::ExprField>,
423 ) -> P<ast::Expr> {
424 self.expr_struct(span, self.path_ident(span, id), fields)
425 }
426
427 pub fn expr_usize(&self, span: Span, n: usize) -> P<ast::Expr> {
428 let suffix = Some(ast::UintTy::Usize.name());
429 let lit = token::Lit::new(token::Integer, sym::integer(n), suffix);
430 self.expr(span, ast::ExprKind::Lit(lit))
431 }
432
433 pub fn expr_u32(&self, span: Span, n: u32) -> P<ast::Expr> {
434 let suffix = Some(ast::UintTy::U32.name());
435 let lit = token::Lit::new(token::Integer, sym::integer(n), suffix);
436 self.expr(span, ast::ExprKind::Lit(lit))
437 }
438
439 pub fn expr_bool(&self, span: Span, value: bool) -> P<ast::Expr> {
440 let lit = token::Lit::new(token::Bool, if value { kw::True } else { kw::False }, None);
441 self.expr(span, ast::ExprKind::Lit(lit))
442 }
443
444 pub fn expr_str(&self, span: Span, s: Symbol) -> P<ast::Expr> {
445 let lit = token::Lit::new(token::Str, literal::escape_string_symbol(s), None);
446 self.expr(span, ast::ExprKind::Lit(lit))
447 }
448
449 pub fn expr_byte_str(&self, span: Span, bytes: Vec<u8>) -> P<ast::Expr> {
450 let lit = token::Lit::new(token::ByteStr, literal::escape_byte_str_symbol(&bytes), None);
451 self.expr(span, ast::ExprKind::Lit(lit))
452 }
453
454 pub fn expr_array(&self, sp: Span, exprs: ThinVec<P<ast::Expr>>) -> P<ast::Expr> {
456 self.expr(sp, ast::ExprKind::Array(exprs))
457 }
458
459 pub fn expr_array_ref(&self, sp: Span, exprs: ThinVec<P<ast::Expr>>) -> P<ast::Expr> {
461 self.expr_addr_of(sp, self.expr_array(sp, exprs))
462 }
463
464 pub fn expr_some(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
465 let some = self.std_path(&[sym::option, sym::Option, sym::Some]);
466 self.expr_call_global(sp, some, thin_vec![expr])
467 }
468
469 pub fn expr_none(&self, sp: Span) -> P<ast::Expr> {
470 let none = self.std_path(&[sym::option, sym::Option, sym::None]);
471 self.expr_path(self.path_global(sp, none))
472 }
473 pub fn expr_tuple(&self, sp: Span, exprs: ThinVec<P<ast::Expr>>) -> P<ast::Expr> {
474 self.expr(sp, ast::ExprKind::Tup(exprs))
475 }
476
477 pub fn expr_unreachable(&self, span: Span) -> P<ast::Expr> {
478 self.expr_macro_call(
479 span,
480 self.macro_call(
481 span,
482 self.path_global(
483 span,
484 [sym::std, sym::unreachable].map(|s| Ident::new(s, span)).to_vec(),
485 ),
486 Delimiter::Parenthesis,
487 TokenStream::default(),
488 ),
489 )
490 }
491
492 pub fn expr_ok(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
493 let ok = self.std_path(&[sym::result, sym::Result, sym::Ok]);
494 self.expr_call_global(sp, ok, thin_vec![expr])
495 }
496
497 pub fn expr_try(&self, sp: Span, head: P<ast::Expr>) -> P<ast::Expr> {
498 let ok = self.std_path(&[sym::result, sym::Result, sym::Ok]);
499 let ok_path = self.path_global(sp, ok);
500 let err = self.std_path(&[sym::result, sym::Result, sym::Err]);
501 let err_path = self.path_global(sp, err);
502
503 let binding_variable = Ident::new(sym::__try_var, sp);
504 let binding_pat = self.pat_ident(sp, binding_variable);
505 let binding_expr = self.expr_ident(sp, binding_variable);
506
507 let ok_pat = self.pat_tuple_struct(sp, ok_path, thin_vec![binding_pat.clone()]);
509
510 let err_pat = self.pat_tuple_struct(sp, err_path.clone(), thin_vec![binding_pat]);
512 let err_inner_expr =
513 self.expr_call(sp, self.expr_path(err_path), thin_vec![binding_expr.clone()]);
514 let err_expr = self.expr(sp, ast::ExprKind::Ret(Some(err_inner_expr)));
516
517 let ok_arm = self.arm(sp, ok_pat, binding_expr);
519 let err_arm = self.arm(sp, err_pat, err_expr);
521
522 self.expr_match(sp, head, thin_vec![ok_arm, err_arm])
524 }
525
526 pub fn pat(&self, span: Span, kind: PatKind) -> P<ast::Pat> {
527 P(ast::Pat { id: ast::DUMMY_NODE_ID, kind, span, tokens: None })
528 }
529 pub fn pat_wild(&self, span: Span) -> P<ast::Pat> {
530 self.pat(span, PatKind::Wild)
531 }
532 pub fn pat_lit(&self, span: Span, expr: P<ast::Expr>) -> P<ast::Pat> {
533 self.pat(span, PatKind::Expr(expr))
534 }
535 pub fn pat_ident(&self, span: Span, ident: Ident) -> P<ast::Pat> {
536 self.pat_ident_binding_mode(span, ident, ast::BindingMode::NONE)
537 }
538
539 pub fn pat_ident_binding_mode(
540 &self,
541 span: Span,
542 ident: Ident,
543 ann: ast::BindingMode,
544 ) -> P<ast::Pat> {
545 let pat = PatKind::Ident(ann, ident.with_span_pos(span), None);
546 self.pat(span, pat)
547 }
548 pub fn pat_path(&self, span: Span, path: ast::Path) -> P<ast::Pat> {
549 self.pat(span, PatKind::Path(None, path))
550 }
551 pub fn pat_tuple_struct(
552 &self,
553 span: Span,
554 path: ast::Path,
555 subpats: ThinVec<P<ast::Pat>>,
556 ) -> P<ast::Pat> {
557 self.pat(span, PatKind::TupleStruct(None, path, subpats))
558 }
559 pub fn pat_struct(
560 &self,
561 span: Span,
562 path: ast::Path,
563 field_pats: ThinVec<ast::PatField>,
564 ) -> P<ast::Pat> {
565 self.pat(span, PatKind::Struct(None, path, field_pats, ast::PatFieldsRest::None))
566 }
567 pub fn pat_tuple(&self, span: Span, pats: ThinVec<P<ast::Pat>>) -> P<ast::Pat> {
568 self.pat(span, PatKind::Tuple(pats))
569 }
570
571 pub fn pat_some(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> {
572 let some = self.std_path(&[sym::option, sym::Option, sym::Some]);
573 let path = self.path_global(span, some);
574 self.pat_tuple_struct(span, path, thin_vec![pat])
575 }
576
577 pub fn arm(&self, span: Span, pat: P<ast::Pat>, expr: P<ast::Expr>) -> ast::Arm {
578 ast::Arm {
579 attrs: AttrVec::new(),
580 pat,
581 guard: None,
582 body: Some(expr),
583 span,
584 id: ast::DUMMY_NODE_ID,
585 is_placeholder: false,
586 }
587 }
588
589 pub fn arm_unreachable(&self, span: Span) -> ast::Arm {
590 self.arm(span, self.pat_wild(span), self.expr_unreachable(span))
591 }
592
593 pub fn expr_match(&self, span: Span, arg: P<ast::Expr>, arms: ThinVec<ast::Arm>) -> P<Expr> {
594 self.expr(span, ast::ExprKind::Match(arg, arms, MatchKind::Prefix))
595 }
596
597 pub fn expr_if(
598 &self,
599 span: Span,
600 cond: P<ast::Expr>,
601 then: P<ast::Expr>,
602 els: Option<P<ast::Expr>>,
603 ) -> P<ast::Expr> {
604 let els = els.map(|x| self.expr_block(self.block_expr(x)));
605 self.expr(span, ast::ExprKind::If(cond, self.block_expr(then), els))
606 }
607
608 pub fn lambda(&self, span: Span, ids: Vec<Ident>, body: P<ast::Expr>) -> P<ast::Expr> {
609 let fn_decl = self.fn_decl(
610 ids.iter().map(|id| self.param(span, *id, self.ty(span, ast::TyKind::Infer))).collect(),
611 ast::FnRetTy::Default(span),
612 );
613
614 self.expr(
619 span,
620 ast::ExprKind::Closure(Box::new(ast::Closure {
621 binder: ast::ClosureBinder::NotPresent,
622 capture_clause: ast::CaptureBy::Ref,
623 constness: ast::Const::No,
624 coroutine_kind: None,
625 movability: ast::Movability::Movable,
626 fn_decl,
627 body,
628 fn_decl_span: span,
629 fn_arg_span: span,
632 })),
633 )
634 }
635
636 pub fn lambda0(&self, span: Span, body: P<ast::Expr>) -> P<ast::Expr> {
637 self.lambda(span, Vec::new(), body)
638 }
639
640 pub fn lambda1(&self, span: Span, body: P<ast::Expr>, ident: Ident) -> P<ast::Expr> {
641 self.lambda(span, vec![ident], body)
642 }
643
644 pub fn lambda_stmts_1(
645 &self,
646 span: Span,
647 stmts: ThinVec<ast::Stmt>,
648 ident: Ident,
649 ) -> P<ast::Expr> {
650 self.lambda1(span, self.expr_block(self.block(span, stmts)), ident)
651 }
652
653 pub fn param(&self, span: Span, ident: Ident, ty: P<ast::Ty>) -> ast::Param {
654 let arg_pat = self.pat_ident(span, ident);
655 ast::Param {
656 attrs: AttrVec::default(),
657 id: ast::DUMMY_NODE_ID,
658 pat: arg_pat,
659 span,
660 ty,
661 is_placeholder: false,
662 }
663 }
664
665 pub fn fn_decl(&self, inputs: ThinVec<ast::Param>, output: ast::FnRetTy) -> P<ast::FnDecl> {
667 P(ast::FnDecl { inputs, output })
668 }
669
670 pub fn item(&self, span: Span, attrs: ast::AttrVec, kind: ast::ItemKind) -> P<ast::Item> {
671 P(ast::Item {
672 attrs,
673 id: ast::DUMMY_NODE_ID,
674 kind,
675 vis: ast::Visibility {
676 span: span.shrink_to_lo(),
677 kind: ast::VisibilityKind::Inherited,
678 tokens: None,
679 },
680 span,
681 tokens: None,
682 })
683 }
684
685 pub fn item_static(
686 &self,
687 span: Span,
688 ident: Ident,
689 ty: P<ast::Ty>,
690 mutability: ast::Mutability,
691 expr: P<ast::Expr>,
692 ) -> P<ast::Item> {
693 self.item(
694 span,
695 AttrVec::new(),
696 ast::ItemKind::Static(
697 ast::StaticItem {
698 ident,
699 ty,
700 safety: ast::Safety::Default,
701 mutability,
702 expr: Some(expr),
703 define_opaque: None,
704 }
705 .into(),
706 ),
707 )
708 }
709
710 pub fn item_const(
711 &self,
712 span: Span,
713 ident: Ident,
714 ty: P<ast::Ty>,
715 expr: P<ast::Expr>,
716 ) -> P<ast::Item> {
717 let defaultness = ast::Defaultness::Final;
718 self.item(
719 span,
720 AttrVec::new(),
721 ast::ItemKind::Const(
722 ast::ConstItem {
723 defaultness,
724 ident,
725 generics: ast::Generics::default(),
727 ty,
728 expr: Some(expr),
729 define_opaque: None,
730 }
731 .into(),
732 ),
733 )
734 }
735
736 pub fn attr_word(&self, name: Symbol, span: Span) -> ast::Attribute {
738 let g = &self.sess.psess.attr_id_generator;
739 attr::mk_attr_word(g, ast::AttrStyle::Outer, ast::Safety::Default, name, span)
740 }
741
742 pub fn attr_name_value_str(&self, name: Symbol, val: Symbol, span: Span) -> ast::Attribute {
746 let g = &self.sess.psess.attr_id_generator;
747 attr::mk_attr_name_value_str(
748 g,
749 ast::AttrStyle::Outer,
750 ast::Safety::Default,
751 name,
752 val,
753 span,
754 )
755 }
756
757 pub fn attr_nested_word(&self, outer: Symbol, inner: Symbol, span: Span) -> ast::Attribute {
759 let g = &self.sess.psess.attr_id_generator;
760 attr::mk_attr_nested_word(
761 g,
762 ast::AttrStyle::Outer,
763 ast::Safety::Default,
764 outer,
765 inner,
766 span,
767 )
768 }
769}