bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

ast/hir: Rename field-related structures

Browse source 
StructField -> FieldDef ("field definition")
Field -> ExprField ("expression field", not "field expression")
FieldPat -> PatField ("pattern field", not "field pattern")

Also rename visiting and other methods working on them.
This commit is contained in:
Vadim Petrochenkov 2021-03-16 00:36:07 +03:00
parent 195ad4830e
commit b25d3ba781
57 changed files with 313 additions and 301 deletions
Download patch file Download diff file Expand all files Collapse all files

66
compiler/rustc_expand/src/base.rs
View file

@ -36,11 +36,11 @@ pub enum Annotatable {
Stmt(P<ast::Stmt>),
Expr(P<ast::Expr>),
Arm(ast::Arm),
Field(ast::Field),
FieldPat(ast::FieldPat),
ExprField(ast::ExprField),
PatField(ast::PatField),
GenericParam(ast::GenericParam),
Param(ast::Param),
StructField(ast::StructField),
FieldDef(ast::FieldDef),
Variant(ast::Variant),
}
@ -54,11 +54,11 @@ impl AstLike for Annotatable {
Annotatable::Stmt(ref stmt) => stmt.attrs(),
Annotatable::Expr(ref expr) => &expr.attrs,
Annotatable::Arm(ref arm) => &arm.attrs,
Annotatable::Field(ref field) => &field.attrs,
Annotatable::FieldPat(ref fp) => &fp.attrs,
Annotatable::ExprField(ref field) => &field.attrs,
Annotatable::PatField(ref fp) => &fp.attrs,
Annotatable::GenericParam(ref gp) => &gp.attrs,
Annotatable::Param(ref p) => &p.attrs,
Annotatable::StructField(ref sf) => &sf.attrs,
Annotatable::FieldDef(ref sf) => &sf.attrs,
Annotatable::Variant(ref v) => &v.attrs(),
}
}
@ -72,11 +72,11 @@ impl AstLike for Annotatable {
Annotatable::Stmt(stmt) => stmt.visit_attrs(f),
Annotatable::Expr(expr) => expr.visit_attrs(f),
Annotatable::Arm(arm) => arm.visit_attrs(f),
Annotatable::Field(field) => field.visit_attrs(f),
Annotatable::FieldPat(fp) => fp.visit_attrs(f),
Annotatable::ExprField(field) => field.visit_attrs(f),
Annotatable::PatField(fp) => fp.visit_attrs(f),
Annotatable::GenericParam(gp) => gp.visit_attrs(f),
Annotatable::Param(p) => p.visit_attrs(f),
Annotatable::StructField(sf) => sf.visit_attrs(f),
Annotatable::FieldDef(sf) => sf.visit_attrs(f),
Annotatable::Variant(v) => v.visit_attrs(f),
}
}
@ -90,11 +90,11 @@ impl AstLike for Annotatable {
Annotatable::Stmt(stmt) => stmt.tokens_mut(),
Annotatable::Expr(expr) => expr.tokens_mut(),
Annotatable::Arm(arm) => arm.tokens_mut(),
Annotatable::Field(field) => field.tokens_mut(),
Annotatable::FieldPat(fp) => fp.tokens_mut(),
Annotatable::ExprField(field) => field.tokens_mut(),
Annotatable::PatField(fp) => fp.tokens_mut(),
Annotatable::GenericParam(gp) => gp.tokens_mut(),
Annotatable::Param(p) => p.tokens_mut(),
Annotatable::StructField(sf) => sf.tokens_mut(),
Annotatable::FieldDef(sf) => sf.tokens_mut(),
Annotatable::Variant(v) => v.tokens_mut(),
}
}
@ -110,11 +110,11 @@ impl Annotatable {
Annotatable::Stmt(ref stmt) => stmt.span,
Annotatable::Expr(ref expr) => expr.span,
Annotatable::Arm(ref arm) => arm.span,
Annotatable::Field(ref field) => field.span,
Annotatable::FieldPat(ref fp) => fp.pat.span,
Annotatable::ExprField(ref field) => field.span,
Annotatable::PatField(ref fp) => fp.pat.span,
Annotatable::GenericParam(ref gp) => gp.ident.span,
Annotatable::Param(ref p) => p.span,
Annotatable::StructField(ref sf) => sf.span,
Annotatable::FieldDef(ref sf) => sf.span,
Annotatable::Variant(ref v) => v.span,
}
}
@ -128,11 +128,11 @@ impl Annotatable {
Annotatable::Stmt(stmt) => visitor.visit_stmt(stmt),
Annotatable::Expr(expr) => visitor.visit_expr(expr),
Annotatable::Arm(arm) => visitor.visit_arm(arm),
Annotatable::Field(field) => visitor.visit_field(field),
Annotatable::FieldPat(fp) => visitor.visit_field_pattern(fp),
Annotatable::ExprField(field) => visitor.visit_expr_field(field),
Annotatable::PatField(fp) => visitor.visit_pat_field(fp),
Annotatable::GenericParam(gp) => visitor.visit_generic_param(gp),
Annotatable::Param(p) => visitor.visit_param(p),
Annotatable::StructField(sf) => visitor.visit_struct_field(sf),
Annotatable::FieldDef(sf) => visitor.visit_field_def(sf),
Annotatable::Variant(v) => visitor.visit_variant(v),
}
}
@ -149,11 +149,11 @@ impl Annotatable {
Annotatable::Stmt(stmt) => token::NtStmt(stmt.into_inner()),
Annotatable::Expr(expr) => token::NtExpr(expr),
Annotatable::Arm(..)
| Annotatable::Field(..)
| Annotatable::FieldPat(..)
| Annotatable::ExprField(..)
| Annotatable::PatField(..)
| Annotatable::GenericParam(..)
| Annotatable::Param(..)
| Annotatable::StructField(..)
| Annotatable::FieldDef(..)
| Annotatable::Variant(..) => panic!("unexpected annotatable"),
}
}
@ -214,16 +214,16 @@ impl Annotatable {
}
}
pub fn expect_field(self) -> ast::Field {
pub fn expect_expr_field(self) -> ast::ExprField {
match self {
Annotatable::Field(field) => field,
Annotatable::ExprField(field) => field,
_ => panic!("expected field"),
}
}
pub fn expect_field_pattern(self) -> ast::FieldPat {
pub fn expect_pat_field(self) -> ast::PatField {
match self {
Annotatable::FieldPat(fp) => fp,
Annotatable::PatField(fp) => fp,
_ => panic!("expected field pattern"),
}
}
@ -242,9 +242,9 @@ impl Annotatable {
}
}
pub fn expect_struct_field(self) -> ast::StructField {
pub fn expect_field_def(self) -> ast::FieldDef {
match self {
Annotatable::StructField(sf) => sf,
Annotatable::FieldDef(sf) => sf,
_ => panic!("expected struct field"),
}
}
@ -430,11 +430,11 @@ pub trait MacResult {
None
}
fn make_fields(self: Box<Self>) -> Option<SmallVec<[ast::Field; 1]>> {
fn make_expr_fields(self: Box<Self>) -> Option<SmallVec<[ast::ExprField; 1]>> {
None
}
fn make_field_patterns(self: Box<Self>) -> Option<SmallVec<[ast::FieldPat; 1]>> {
fn make_pat_fields(self: Box<Self>) -> Option<SmallVec<[ast::PatField; 1]>> {
None
}
@ -446,7 +446,7 @@ pub trait MacResult {
None
}
fn make_struct_fields(self: Box<Self>) -> Option<SmallVec<[ast::StructField; 1]>> {
fn make_field_defs(self: Box<Self>) -> Option<SmallVec<[ast::FieldDef; 1]>> {
None
}
@ -630,11 +630,11 @@ impl MacResult for DummyResult {
Some(SmallVec::new())
}
fn make_fields(self: Box<DummyResult>) -> Option<SmallVec<[ast::Field; 1]>> {
fn make_expr_fields(self: Box<DummyResult>) -> Option<SmallVec<[ast::ExprField; 1]>> {
Some(SmallVec::new())
}
fn make_field_patterns(self: Box<DummyResult>) -> Option<SmallVec<[ast::FieldPat; 1]>> {
fn make_pat_fields(self: Box<DummyResult>) -> Option<SmallVec<[ast::PatField; 1]>> {
Some(SmallVec::new())
}
@ -646,7 +646,7 @@ impl MacResult for DummyResult {
Some(SmallVec::new())
}
fn make_struct_fields(self: Box<DummyResult>) -> Option<SmallVec<[ast::StructField; 1]>> {
fn make_field_defs(self: Box<DummyResult>) -> Option<SmallVec<[ast::FieldDef; 1]>> {
Some(SmallVec::new())
}

10
compiler/rustc_expand/src/build.rs
View file

@ -267,8 +267,8 @@ impl<'a> ExtCtxt<'a> {
pub fn expr_block(&self, b: P<ast::Block>) -> P<ast::Expr> {
self.expr(b.span, ast::ExprKind::Block(b, None))
}
pub fn field_imm(&self, span: Span, ident: Ident, e: P<ast::Expr>) -> ast::Field {
ast::Field {
pub fn field_imm(&self, span: Span, ident: Ident, e: P<ast::Expr>) -> ast::ExprField {
ast::ExprField {
ident: ident.with_span_pos(span),
expr: e,
span,
@ -282,7 +282,7 @@ impl<'a> ExtCtxt<'a> {
&self,
span: Span,
path: ast::Path,
fields: Vec<ast::Field>,
fields: Vec<ast::ExprField>,
) -> P<ast::Expr> {
self.expr(span, ast::ExprKind::Struct(path, fields, ast::StructRest::None))
}
@ -290,7 +290,7 @@ impl<'a> ExtCtxt<'a> {
&self,
span: Span,
id: Ident,
fields: Vec<ast::Field>,
fields: Vec<ast::ExprField>,
) -> P<ast::Expr> {
self.expr_struct(span, self.path_ident(span, id), fields)
}
@ -419,7 +419,7 @@ impl<'a> ExtCtxt<'a> {
&self,
span: Span,
path: ast::Path,
field_pats: Vec<ast::FieldPat>,
field_pats: Vec<ast::PatField>,
) -> P<ast::Pat> {
self.pat(span, PatKind::Struct(path, field_pats, false))
}

60
compiler/rustc_expand/src/expand.rs
View file

@ -177,14 +177,14 @@ ast_fragments! {
Arms(SmallVec<[ast::Arm; 1]>) {
"match arm"; many fn flat_map_arm; fn visit_arm(); fn make_arms;
}
Fields(SmallVec<[ast::Field; 1]>) {
"field expression"; many fn flat_map_field; fn visit_field(); fn make_fields;
Fields(SmallVec<[ast::ExprField; 1]>) {
"field expression"; many fn flat_map_expr_field; fn visit_expr_field(); fn make_expr_fields;
}
FieldPats(SmallVec<[ast::FieldPat; 1]>) {
FieldPats(SmallVec<[ast::PatField; 1]>) {
"field pattern";
many fn flat_map_field_pattern;
fn visit_field_pattern();
fn make_field_patterns;
many fn flat_map_pat_field;
fn visit_pat_field();
fn make_pat_fields;
}
GenericParams(SmallVec<[ast::GenericParam; 1]>) {
"generic parameter";
@ -195,11 +195,11 @@ ast_fragments! {
Params(SmallVec<[ast::Param; 1]>) {
"function parameter"; many fn flat_map_param; fn visit_param(); fn make_params;
}
StructFields(SmallVec<[ast::StructField; 1]>) {
StructFields(SmallVec<[ast::FieldDef; 1]>) {
"field";
many fn flat_map_struct_field;
fn visit_struct_field();
fn make_struct_fields;
many fn flat_map_field_def;
fn visit_field_def();
fn make_field_defs;
}
Variants(SmallVec<[ast::Variant; 1]>) {
"variant"; many fn flat_map_variant; fn visit_variant(); fn make_variants;
@ -243,10 +243,10 @@ impl AstFragmentKind {
AstFragment::Arms(items.map(Annotatable::expect_arm).collect())
}
AstFragmentKind::Fields => {
AstFragment::Fields(items.map(Annotatable::expect_field).collect())
AstFragment::Fields(items.map(Annotatable::expect_expr_field).collect())
}
AstFragmentKind::FieldPats => {
AstFragment::FieldPats(items.map(Annotatable::expect_field_pattern).collect())
AstFragment::FieldPats(items.map(Annotatable::expect_pat_field).collect())
}
AstFragmentKind::GenericParams => {
AstFragment::GenericParams(items.map(Annotatable::expect_generic_param).collect())
@ -255,7 +255,7 @@ impl AstFragmentKind {
AstFragment::Params(items.map(Annotatable::expect_param).collect())
}
AstFragmentKind::StructFields => {
AstFragment::StructFields(items.map(Annotatable::expect_struct_field).collect())
AstFragment::StructFields(items.map(Annotatable::expect_field_def).collect())
}
AstFragmentKind::Variants => {
AstFragment::Variants(items.map(Annotatable::expect_variant).collect())
@ -321,8 +321,8 @@ impl InvocationKind {
// The assumption is that the attribute expansion cannot change field visibilities,
// and it holds because only inert attributes are supported in this position.
match self {
InvocationKind::Attr { item: Annotatable::StructField(field), .. }
| InvocationKind::Derive { item: Annotatable::StructField(field), .. }
InvocationKind::Attr { item: Annotatable::FieldDef(field), .. }
| InvocationKind::Derive { item: Annotatable::FieldDef(field), .. }
if field.ident.is_none() =>
{
Some(field.vis.clone())
@ -787,11 +787,11 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
}
Annotatable::Expr(_) => "expressions",
Annotatable::Arm(..)
| Annotatable::Field(..)
| Annotatable::FieldPat(..)
| Annotatable::ExprField(..)
| Annotatable::PatField(..)
| Annotatable::GenericParam(..)
| Annotatable::Param(..)
| Annotatable::StructField(..)
| Annotatable::FieldDef(..)
| Annotatable::Variant(..) => panic!("unexpected annotatable"),
};
if self.cx.ecfg.proc_macro_hygiene() {
@ -1108,28 +1108,28 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
noop_flat_map_arm(arm, self)
}
fn flat_map_field(&mut self, field: ast::Field) -> SmallVec<[ast::Field; 1]> {
fn flat_map_expr_field(&mut self, field: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> {
let mut field = configure!(self, field);
if let Some(attr) = self.take_first_attr(&mut field) {
return self
.collect_attr(attr, Annotatable::Field(field), AstFragmentKind::Fields)
.make_fields();
.collect_attr(attr, Annotatable::ExprField(field), AstFragmentKind::Fields)
.make_expr_fields();
}
noop_flat_map_field(field, self)
noop_flat_map_expr_field(field, self)
}
fn flat_map_field_pattern(&mut self, fp: ast::FieldPat) -> SmallVec<[ast::FieldPat; 1]> {
fn flat_map_pat_field(&mut self, fp: ast::PatField) -> SmallVec<[ast::PatField; 1]> {
let mut fp = configure!(self, fp);
if let Some(attr) = self.take_first_attr(&mut fp) {
return self
.collect_attr(attr, Annotatable::FieldPat(fp), AstFragmentKind::FieldPats)
.make_field_patterns();
.collect_attr(attr, Annotatable::PatField(fp), AstFragmentKind::FieldPats)
.make_pat_fields();
}
noop_flat_map_field_pattern(fp, self)
noop_flat_map_pat_field(fp, self)
}
fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> {
@ -1144,16 +1144,16 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
noop_flat_map_param(p, self)
}
fn flat_map_struct_field(&mut self, sf: ast::StructField) -> SmallVec<[ast::StructField; 1]> {
fn flat_map_field_def(&mut self, sf: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> {
let mut sf = configure!(self, sf);
if let Some(attr) = self.take_first_attr(&mut sf) {
return self
.collect_attr(attr, Annotatable::StructField(sf), AstFragmentKind::StructFields)
.make_struct_fields();
.collect_attr(attr, Annotatable::FieldDef(sf), AstFragmentKind::StructFields)
.make_field_defs();
}
noop_flat_map_struct_field(sf, self)
noop_flat_map_field_def(sf, self)
}
fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> {

24
compiler/rustc_expand/src/placeholders.rs
View file

@ -117,7 +117,7 @@ pub fn placeholder(
span,
is_placeholder: true,
}]),
AstFragmentKind::Fields => AstFragment::Fields(smallvec![ast::Field {
AstFragmentKind::Fields => AstFragment::Fields(smallvec![ast::ExprField {
attrs: Default::default(),
expr: expr_placeholder(),
id,
@ -126,7 +126,7 @@ pub fn placeholder(
span,
is_placeholder: true,
}]),
AstFragmentKind::FieldPats => AstFragment::FieldPats(smallvec![ast::FieldPat {
AstFragmentKind::FieldPats => AstFragment::FieldPats(smallvec![ast::PatField {
attrs: Default::default(),
id,
ident,
@ -153,7 +153,7 @@ pub fn placeholder(
ty: ty(),
is_placeholder: true,
}]),
AstFragmentKind::StructFields => AstFragment::StructFields(smallvec![ast::StructField {
AstFragmentKind::StructFields => AstFragment::StructFields(smallvec![ast::FieldDef {
attrs: Default::default(),
id,
ident: None,
@ -205,19 +205,19 @@ impl<'a, 'b> MutVisitor for PlaceholderExpander<'a, 'b> {
}
}
fn flat_map_field(&mut self, field: ast::Field) -> SmallVec<[ast::Field; 1]> {
fn flat_map_expr_field(&mut self, field: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> {
if field.is_placeholder {
self.remove(field.id).make_fields()
self.remove(field.id).make_expr_fields()
} else {
noop_flat_map_field(field, self)
noop_flat_map_expr_field(field, self)
}
}
fn flat_map_field_pattern(&mut self, fp: ast::FieldPat) -> SmallVec<[ast::FieldPat; 1]> {
fn flat_map_pat_field(&mut self, fp: ast::PatField) -> SmallVec<[ast::PatField; 1]> {
if fp.is_placeholder {
self.remove(fp.id).make_field_patterns()
self.remove(fp.id).make_pat_fields()
} else {
noop_flat_map_field_pattern(fp, self)
noop_flat_map_pat_field(fp, self)
}
}
@ -240,11 +240,11 @@ impl<'a, 'b> MutVisitor for PlaceholderExpander<'a, 'b> {
}
}
fn flat_map_struct_field(&mut self, sf: ast::StructField) -> SmallVec<[ast::StructField; 1]> {
fn flat_map_field_def(&mut self, sf: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> {
if sf.is_placeholder {
self.remove(sf.id).make_struct_fields()
self.remove(sf.id).make_field_defs()
} else {
noop_flat_map_struct_field(sf, self)
noop_flat_map_field_def(sf, self)
}
}