//! that are created by the expansion of a macro.
use crate::ast::*;
-use crate::source_map::{Spanned, respan};
-use crate::token::{self, Token};
use crate::ptr::P;
+use crate::token::{self, Token};
use crate::tokenstream::*;
use crate::util::map_in_place::MapInPlace;
-use smallvec::{smallvec, Array, SmallVec};
-use syntax_pos::Span;
-
use rustc_data_structures::sync::Lrc;
+use rustc_span::source_map::{respan, Spanned};
+use rustc_span::Span;
+
+use smallvec::{smallvec, Array, SmallVec};
use std::ops::DerefMut;
use std::{panic, process, ptr};
noop_visit_foreign_mod(nm, self);
}
- fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> {
+ fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> {
noop_flat_map_variant(v, self)
}
/// method. Abort the program if the closure panics.
//
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-pub fn visit_clobber<T, F>(t: &mut T, f: F) where F: FnOnce(T) -> T {
+pub fn visit_clobber<T, F>(t: &mut T, f: F)
+where
+ F: FnOnce(T) -> T,
+{
unsafe {
// Safe because `t` is used in a read-only fashion by `read()` before
// being overwritten by `write()`.
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
#[inline]
-pub fn visit_vec<T, F>(elems: &mut Vec<T>, mut visit_elem: F) where F: FnMut(&mut T) {
+pub fn visit_vec<T, F>(elems: &mut Vec<T>, mut visit_elem: F)
+where
+ F: FnMut(&mut T),
+{
for elem in elems {
visit_elem(elem);
}
// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
#[inline]
-pub fn visit_opt<T, F>(opt: &mut Option<T>, mut visit_elem: F) where F: FnMut(&mut T) {
+pub fn visit_opt<T, F>(opt: &mut Option<T>, mut visit_elem: F)
+where
+ F: FnMut(&mut T),
+{
if let Some(elem) = opt {
visit_elem(elem);
}
mut fp: FieldPat,
vis: &mut T,
) -> SmallVec<[FieldPat; 1]> {
- let FieldPat {
- attrs,
- id,
- ident,
- is_placeholder: _,
- is_shorthand: _,
- pat,
- span,
- } = &mut fp;
+ let FieldPat { attrs, id, ident, is_placeholder: _, is_shorthand: _, pat, span } = &mut fp;
vis.visit_id(id);
vis.visit_ident(ident);
vis.visit_pat(pat);
pub fn noop_visit_ty_constraint<T: MutVisitor>(
AssocTyConstraint { id, ident, kind, span }: &mut AssocTyConstraint,
- vis: &mut T
+ vis: &mut T,
) {
vis.visit_id(id);
vis.visit_ident(ident);
let Ty { id, kind, span } = ty.deref_mut();
vis.visit_id(id);
match kind {
- TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err |
- TyKind::Never | TyKind::CVarArgs => {}
+ TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err | TyKind::Never | TyKind::CVarArgs => {}
TyKind::Slice(ty) => vis.visit_ty(ty),
TyKind::Ptr(mt) => vis.visit_mt(mt),
TyKind::Rptr(lt, mt) => {
vis.visit_anon_const(length);
}
TyKind::Typeof(expr) => vis.visit_anon_const(expr),
- TyKind::TraitObject(bounds, _syntax) =>
- visit_vec(bounds, |bound| vis.visit_param_bound(bound)),
+ TyKind::TraitObject(bounds, _syntax) => {
+ visit_vec(bounds, |bound| vis.visit_param_bound(bound))
+ }
TyKind::ImplTrait(id, bounds) => {
vis.visit_id(id);
visit_vec(bounds, |bound| vis.visit_param_bound(bound));
}
pub fn noop_visit_foreign_mod<T: MutVisitor>(foreign_mod: &mut ForeignMod, vis: &mut T) {
- let ForeignMod { abi: _, items} = foreign_mod;
+ let ForeignMod { abi: _, items } = foreign_mod;
items.flat_map_in_place(|item| vis.flat_map_foreign_item(item));
}
-pub fn noop_flat_map_variant<T: MutVisitor>(mut variant: Variant, visitor: &mut T)
- -> SmallVec<[Variant; 1]>
-{
+pub fn noop_flat_map_variant<T: MutVisitor>(
+ mut variant: Variant,
+ visitor: &mut T,
+) -> SmallVec<[Variant; 1]> {
let Variant { ident, vis, attrs, id, data, disr_expr, span, is_placeholder: _ } = &mut variant;
visitor.visit_ident(ident);
visitor.visit_vis(vis);
}
}
-pub fn noop_visit_angle_bracketed_parameter_data<T: MutVisitor>(data: &mut AngleBracketedArgs,
- vis: &mut T) {
+pub fn noop_visit_angle_bracketed_parameter_data<T: MutVisitor>(
+ data: &mut AngleBracketedArgs,
+ vis: &mut T,
+) {
let AngleBracketedArgs { args, constraints, span } = data;
visit_vec(args, |arg| vis.visit_generic_arg(arg));
visit_vec(constraints, |constraint| vis.visit_ty_constraint(constraint));
vis.visit_span(span);
}
-pub fn noop_visit_parenthesized_parameter_data<T: MutVisitor>(args: &mut ParenthesizedArgs,
- vis: &mut T) {
+pub fn noop_visit_parenthesized_parameter_data<T: MutVisitor>(
+ args: &mut ParenthesizedArgs,
+ vis: &mut T,
+) {
let ParenthesizedArgs { inputs, output, span } = args;
visit_vec(inputs, |input| vis.visit_ty(input));
noop_visit_fn_ret_ty(output, vis);
// multiple items there....
pub fn noop_visit_interpolated<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut T) {
match nt {
- token::NtItem(item) =>
- visit_clobber(item, |item| {
- // This is probably okay, because the only visitors likely to
- // peek inside interpolated nodes will be renamings/markings,
- // which map single items to single items.
- vis.flat_map_item(item).expect_one("expected visitor to produce exactly one item")
- }),
+ token::NtItem(item) => visit_clobber(item, |item| {
+ // This is probably okay, because the only visitors likely to
+ // peek inside interpolated nodes will be renamings/markings,
+ // which map single items to single items.
+ vis.flat_map_item(item).expect_one("expected visitor to produce exactly one item")
+ }),
token::NtBlock(block) => vis.visit_block(block),
- token::NtStmt(stmt) =>
- visit_clobber(stmt, |stmt| {
- // See reasoning above.
- vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item")
- }),
+ token::NtStmt(stmt) => visit_clobber(stmt, |stmt| {
+ // See reasoning above.
+ vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item")
+ }),
token::NtPat(pat) => vis.visit_pat(pat),
token::NtExpr(expr) => vis.visit_expr(expr),
token::NtTy(ty) => vis.visit_ty(ty),
}
token::NtPath(path) => vis.visit_path(path),
token::NtTT(tt) => vis.visit_tt(tt),
- token::NtImplItem(item) =>
- visit_clobber(item, |item| {
- // See reasoning above.
- vis.flat_map_impl_item(item)
- .expect_one("expected visitor to produce exactly one item")
- }),
- token::NtTraitItem(item) =>
- visit_clobber(item, |item| {
- // See reasoning above.
- vis.flat_map_trait_item(item)
- .expect_one("expected visitor to produce exactly one item")
- }),
+ token::NtImplItem(item) => visit_clobber(item, |item| {
+ // See reasoning above.
+ vis.flat_map_impl_item(item).expect_one("expected visitor to produce exactly one item")
+ }),
+ token::NtTraitItem(item) => visit_clobber(item, |item| {
+ // See reasoning above.
+ vis.flat_map_trait_item(item).expect_one("expected visitor to produce exactly one item")
+ }),
token::NtVis(visib) => vis.visit_vis(visib),
- token::NtForeignItem(item) =>
- visit_clobber(item, |item| {
- // See reasoning above.
- vis.flat_map_foreign_item(item)
- .expect_one("expected visitor to produce exactly one item")
- }),
+ token::NtForeignItem(item) => visit_clobber(item, |item| {
+ // See reasoning above.
+ vis.flat_map_foreign_item(item)
+ .expect_one("expected visitor to produce exactly one item")
+ }),
}
}
pub fn noop_flat_map_generic_param<T: MutVisitor>(
mut param: GenericParam,
- vis: &mut T
-) -> SmallVec<[GenericParam; 1]>
-{
+ vis: &mut T,
+) -> SmallVec<[GenericParam; 1]> {
let GenericParam { id, ident, attrs, bounds, kind, is_placeholder: _ } = &mut param;
vis.visit_id(id);
vis.visit_ident(ident);
match vdata {
VariantData::Struct(fields, ..) => {
fields.flat_map_in_place(|field| vis.flat_map_struct_field(field));
- },
+ }
VariantData::Tuple(fields, id) => {
fields.flat_map_in_place(|field| vis.flat_map_struct_field(field));
vis.visit_id(id);
- },
+ }
VariantData::Unit(id) => vis.visit_id(id),
}
}
-pub fn noop_visit_trait_ref<T: MutVisitor>(TraitRef { path, ref_id }: &mut TraitRef, vis: &mut T) {
+pub fn noop_visit_trait_ref<T: MutVisitor>(tr: &mut TraitRef, vis: &mut T) {
+ let TraitRef { path, ref_id, constness: _ } = tr;
vis.visit_path(path);
vis.visit_id(ref_id);
}
vis.visit_span(span);
}
-pub fn noop_flat_map_struct_field<T: MutVisitor>(mut sf: StructField, visitor: &mut T)
- -> SmallVec<[StructField; 1]>
-{
+pub fn noop_flat_map_struct_field<T: MutVisitor>(
+ mut sf: StructField,
+ visitor: &mut T,
+) -> SmallVec<[StructField; 1]> {
let StructField { span, ident, vis, id, ty, attrs, is_placeholder: _ } = &mut sf;
visitor.visit_span(span);
visit_opt(ident, |ident| visitor.visit_ident(ident));
variants.flat_map_in_place(|variant| vis.flat_map_variant(variant));
vis.visit_generics(generics);
}
- ItemKind::Struct(variant_data, generics) |
- ItemKind::Union(variant_data, generics) => {
+ ItemKind::Struct(variant_data, generics) | ItemKind::Union(variant_data, generics) => {
vis.visit_variant_data(variant_data);
vis.visit_generics(generics);
}
}
}
-pub fn noop_flat_map_assoc_item<T: MutVisitor>(mut item: AssocItem, visitor: &mut T)
- -> SmallVec<[AssocItem; 1]>
-{
+pub fn noop_flat_map_assoc_item<T: MutVisitor>(
+ mut item: AssocItem,
+ visitor: &mut T,
+) -> SmallVec<[AssocItem; 1]> {
let AssocItem { id, ident, vis, defaultness: _, attrs, generics, kind, span, tokens: _ } =
&mut item;
visitor.visit_id(id);
visitor.visit_vis(vis);
visit_attrs(attrs, visitor);
visitor.visit_generics(generics);
- match kind {
+ match kind {
AssocItemKind::Const(ty, expr) => {
visitor.visit_ty(ty);
visit_opt(expr, |expr| visitor.visit_expr(expr));
}
// Mutates one item into possibly many items.
-pub fn noop_flat_map_item<T: MutVisitor>(mut item: P<Item>, visitor: &mut T)
- -> SmallVec<[P<Item>; 1]> {
+pub fn noop_flat_map_item<T: MutVisitor>(
+ mut item: P<Item>,
+ visitor: &mut T,
+) -> SmallVec<[P<Item>; 1]> {
let Item { ident, attrs, id, kind, vis, span, tokens: _ } = item.deref_mut();
visitor.visit_ident(ident);
visit_attrs(attrs, visitor);
smallvec![item]
}
-pub fn noop_flat_map_foreign_item<T: MutVisitor>(mut item: ForeignItem, visitor: &mut T)
- -> SmallVec<[ForeignItem; 1]>
-{
+pub fn noop_flat_map_foreign_item<T: MutVisitor>(
+ mut item: ForeignItem,
+ visitor: &mut T,
+) -> SmallVec<[ForeignItem; 1]> {
let ForeignItem { ident, attrs, id, kind, vis, span, tokens: _ } = &mut item;
visitor.visit_ident(ident);
visit_attrs(attrs, visitor);
PatKind::Box(inner) => vis.visit_pat(inner),
PatKind::Ref(inner, _mutbl) => vis.visit_pat(inner),
PatKind::Range(e1, e2, Spanned { span: _, node: _ }) => {
- vis.visit_expr(e1);
- vis.visit_expr(e2);
+ visit_opt(e1, |e| vis.visit_expr(e));
+ visit_opt(e2, |e| vis.visit_expr(e));
vis.visit_span(span);
}
- PatKind::Tuple(elems)
- | PatKind::Slice(elems)
- | PatKind::Or(elems) => visit_vec(elems, |elem| vis.visit_pat(elem)),
+ PatKind::Tuple(elems) | PatKind::Slice(elems) | PatKind::Or(elems) => {
+ visit_vec(elems, |elem| vis.visit_pat(elem))
+ }
PatKind::Paren(inner) => vis.visit_pat(inner),
PatKind::Mac(mac) => vis.visit_mac(mac),
}
vis.visit_block(body);
}
ExprKind::Await(expr) => vis.visit_expr(expr),
- ExprKind::Assign(el, er) => {
+ ExprKind::Assign(el, er, _) => {
vis.visit_expr(el);
vis.visit_expr(er);
}
visit_opt(expr, |expr| vis.visit_expr(expr));
}
ExprKind::InlineAsm(asm) => {
- let InlineAsm { asm: _, asm_str_style: _, outputs, inputs, clobbers: _, volatile: _,
- alignstack: _, dialect: _ } = asm.deref_mut();
+ let InlineAsm {
+ asm: _,
+ asm_str_style: _,
+ outputs,
+ inputs,
+ clobbers: _,
+ volatile: _,
+ alignstack: _,
+ dialect: _,
+ } = asm.deref_mut();
for out in outputs {
let InlineAsmOutput { constraint: _, expr, is_rw: _, is_indirect: _ } = out;
vis.visit_expr(expr);
vis.visit_path(path);
fields.flat_map_in_place(|field| vis.flat_map_field(field));
visit_opt(expr, |expr| vis.visit_expr(expr));
- },
+ }
ExprKind::Paren(expr) => {
vis.visit_expr(expr);
}
pub fn noop_filter_map_expr<T: MutVisitor>(mut e: P<Expr>, vis: &mut T) -> Option<P<Expr>> {
- Some({ vis.visit_expr(&mut e); e })
+ Some({
+ vis.visit_expr(&mut e);
+ e
+ })
}
-pub fn noop_flat_map_stmt<T: MutVisitor>(Stmt { kind, mut span, mut id }: Stmt, vis: &mut T)
- -> SmallVec<[Stmt; 1]>
-{
+pub fn noop_flat_map_stmt<T: MutVisitor>(
+ Stmt { kind, mut span, mut id }: Stmt,
+ vis: &mut T,
+) -> SmallVec<[Stmt; 1]> {
vis.visit_id(&mut id);
vis.visit_span(&mut span);
- noop_flat_map_stmt_kind(kind, vis).into_iter().map(|kind| {
- Stmt { id, kind, span }
- }).collect()
+ noop_flat_map_stmt_kind(kind, vis).into_iter().map(|kind| Stmt { id, kind, span }).collect()
}
-pub fn noop_flat_map_stmt_kind<T: MutVisitor>(kind: StmtKind, vis: &mut T)
- -> SmallVec<[StmtKind; 1]> {
+pub fn noop_flat_map_stmt_kind<T: MutVisitor>(
+ kind: StmtKind,
+ vis: &mut T,
+) -> SmallVec<[StmtKind; 1]> {
match kind {
- StmtKind::Local(mut local) =>
- smallvec![StmtKind::Local({ vis.visit_local(&mut local); local })],
+ StmtKind::Local(mut local) => smallvec![StmtKind::Local({
+ vis.visit_local(&mut local);
+ local
+ })],
StmtKind::Item(item) => vis.flat_map_item(item).into_iter().map(StmtKind::Item).collect(),
- StmtKind::Expr(expr) => {
- vis.filter_map_expr(expr).into_iter().map(StmtKind::Expr).collect()
- }
- StmtKind::Semi(expr) => {
- vis.filter_map_expr(expr).into_iter().map(StmtKind::Semi).collect()
- }
+ StmtKind::Expr(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Expr).collect(),
+ StmtKind::Semi(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Semi).collect(),
StmtKind::Mac(mut mac) => {
let (mac_, _semi, attrs) = mac.deref_mut();
vis.visit_mac(mac_);
projects / rust.git / blobdiff