nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-22 20:03:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Adjust 'ast::PatKind::{TupleStruct,Tuple,Slice}'.

Browse Source
This commit is contained in:
Mazdak Farrokhzad 2019-07-09 09:25:18 +02:00
parent ff77ef2d70
commit 633c9972ac
4 changed files with 21 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/libsyntax/ast.rs
View File

@ -559,18 +559,13 @@ impl Pat {
return false;
}
match self.node {
PatKind::Ident(_, _, Some(ref p)) => p.walk(it),
PatKind::Struct(_, ref fields, _) => fields.iter().all(|field| field.node.pat.walk(it)),
PatKind::TupleStruct(_, ref s, _) | PatKind::Tuple(ref s, _) => {
match &self.node {
PatKind::Ident(_, _, Some(p)) => p.walk(it),
PatKind::Struct(_, fields, _) => fields.iter().all(|field| field.node.pat.walk(it)),
PatKind::TupleStruct(_, s) | PatKind::Tuple(s) | PatKind::Slice(s) => {
s.iter().all(|p| p.walk(it))
}
PatKind::Box(ref s) | PatKind::Ref(ref s, _) | PatKind::Paren(ref s) => s.walk(it),
PatKind::Slice(ref before, ref slice, ref after) => {
before.iter().all(|p| p.walk(it))
&& slice.iter().all(|p| p.walk(it))
&& after.iter().all(|p| p.walk(it))
}
PatKind::Box(s) | PatKind::Ref(s, _) | PatKind::Paren(s) => s.walk(it),
PatKind::Wild
| PatKind::Rest
| PatKind::Lit(_)
@ -639,9 +634,7 @@ pub enum PatKind {
Struct(Path, Vec<Spanned<FieldPat>>, /* recovered */ bool),
/// A tuple struct/variant pattern (`Variant(x, y, .., z)`).
/// If the `..` pattern fragment is present, then `Option<usize>` denotes its position.
/// `0 <= position <= subpats.len()`.
TupleStruct(Path, Vec<P<Pat>>, Option<usize>),
TupleStruct(Path, Vec<P<Pat>>),
/// A possibly qualified path pattern.
/// Unqualified path patterns `A::B::C` can legally refer to variants, structs, constants
@ -650,9 +643,7 @@ pub enum PatKind {
Path(Option<QSelf>, Path),
/// A tuple pattern (`(a, b)`).
/// If the `..` pattern fragment is present, then `Option<usize>` denotes its position.
/// `0 <= position <= subpats.len()`.
Tuple(Vec<P<Pat>>, Option<usize>),
Tuple(Vec<P<Pat>>),
/// A `box` pattern.
Box(P<Pat>),
@ -666,9 +657,8 @@ pub enum PatKind {
/// A range pattern (e.g., `1...2`, `1..=2` or `1..2`).
Range(P<Expr>, P<Expr>, Spanned<RangeEnd>),
/// `[a, b, ..i, y, z]` is represented as:
/// `PatKind::Slice(box [a, b], Some(i), box [y, z])`
Slice(Vec<P<Pat>>, Option<P<Pat>>, Vec<P<Pat>>),
/// A slice pattern `[a, b, c]`.
Slice(Vec<P<Pat>>),
/// A rest pattern `..`.
///

4
src/libsyntax/ext/build.rs
View File

@ -840,14 +840,14 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}
fn pat_tuple_struct(&self, span: Span, path: ast::Path,
subpats: Vec<P<ast::Pat>>) -> P<ast::Pat> {
self.pat(span, PatKind::TupleStruct(path, subpats, None))
self.pat(span, PatKind::TupleStruct(path, subpats))
}
fn pat_struct(&self, span: Span, path: ast::Path,
field_pats: Vec<Spanned<ast::FieldPat>>) -> P<ast::Pat> {
self.pat(span, PatKind::Struct(path, field_pats, false))
}
fn pat_tuple(&self, span: Span, pats: Vec<P<ast::Pat>>) -> P<ast::Pat> {
self.pat(span, PatKind::Tuple(pats, None))
self.pat(span, PatKind::Tuple(pats))
}
fn pat_some(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> {

12
src/libsyntax/mut_visit.rs
View File

@ -1026,9 +1026,9 @@ pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
visit_opt(sub, |sub| vis.visit_pat(sub));
}
PatKind::Lit(e) => vis.visit_expr(e),
PatKind::TupleStruct(path, pats, _ddpos) => {
PatKind::TupleStruct(path, elems) => {
vis.visit_path(path);
visit_vec(pats, |pat| vis.visit_pat(pat));
visit_vec(elems, |elem| vis.visit_pat(elem));
}
PatKind::Path(qself, path) => {
vis.visit_qself(qself);
@ -1043,7 +1043,7 @@ pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
vis.visit_span(span);
};
}
PatKind::Tuple(elts, _ddpos) => visit_vec(elts, |elt| vis.visit_pat(elt)),
PatKind::Tuple(elems) => visit_vec(elems, |elem| vis.visit_pat(elem)),
PatKind::Box(inner) => vis.visit_pat(inner),
PatKind::Ref(inner, _mutbl) => vis.visit_pat(inner),
PatKind::Range(e1, e2, Spanned { span: _, node: _ }) => {
@ -1051,11 +1051,7 @@ pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
vis.visit_expr(e2);
vis.visit_span(span);
}
PatKind::Slice(before, slice, after) => {
visit_vec(before, |pat| vis.visit_pat(pat));
visit_opt(slice, |slice| vis.visit_pat(slice));
visit_vec(after, |pat| vis.visit_pat(pat));
}
PatKind::Slice(elems) => visit_vec(elems, |elem| vis.visit_pat(elem)),
PatKind::Paren(inner) => vis.visit_pat(inner),
PatKind::Mac(mac) => vis.visit_mac(mac),
}

14
src/libsyntax/visit.rs
View File

@ -428,9 +428,9 @@ pub fn walk_assoc_ty_constraint<'a, V: Visitor<'a>>(visitor: &mut V,
pub fn walk_pat<'a, V: Visitor<'a>>(visitor: &mut V, pattern: &'a Pat) {
match pattern.node {
PatKind::TupleStruct(ref path, ref children, _) => {
PatKind::TupleStruct(ref path, ref elems) => {
visitor.visit_path(path, pattern.id);
walk_list!(visitor, visit_pat, children);
walk_list!(visitor, visit_pat, elems);
}
PatKind::Path(ref opt_qself, ref path) => {
if let Some(ref qself) = *opt_qself {
@ -446,8 +446,8 @@ pub fn walk_pat<'a, V: Visitor<'a>>(visitor: &mut V, pattern: &'a Pat) {
visitor.visit_pat(&field.node.pat)
}
}
PatKind::Tuple(ref tuple_elements, _) => {
walk_list!(visitor, visit_pat, tuple_elements);
PatKind::Tuple(ref elems) => {
walk_list!(visitor, visit_pat, elems);
}
PatKind::Box(ref subpattern) |
PatKind::Ref(ref subpattern, _) |
@ -464,10 +464,8 @@ pub fn walk_pat<'a, V: Visitor<'a>>(visitor: &mut V, pattern: &'a Pat) {
visitor.visit_expr(upper_bound);
}
PatKind::Wild | PatKind::Rest => {},
PatKind::Slice(ref prepatterns, ref slice_pattern, ref postpatterns) => {
walk_list!(visitor, visit_pat, prepatterns);
walk_list!(visitor, visit_pat, slice_pattern);
walk_list!(visitor, visit_pat, postpatterns);
PatKind::Slice(ref elems) => {
walk_list!(visitor, visit_pat, elems);
}
PatKind::Mac(ref mac) => visitor.visit_mac(mac),
}