about summary refs log tree commit diff
path: root/src/libsyntax/parse
diff options
context:
space:
mode:
Diffstat (limited to 'src/libsyntax/parse')
-rw-r--r--src/libsyntax/parse/diagnostics.rs10
-rw-r--r--src/libsyntax/parse/parser.rs2
-rw-r--r--src/libsyntax/parse/parser/expr.rs4
-rw-r--r--src/libsyntax/parse/parser/item.rs6
-rw-r--r--src/libsyntax/parse/parser/ty.rs6
5 files changed, 14 insertions, 14 deletions
diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/diagnostics.rs
index ecc1cdd8bca..62cb836e31e 100644
--- a/src/libsyntax/parse/diagnostics.rs
+++ b/src/libsyntax/parse/diagnostics.rs
@@ -25,7 +25,7 @@ crate fn dummy_arg(ident: Ident) -> Param {
         span: ident.span,
     });
     let ty = Ty {
-        node: TyKind::Err,
+        kind: TyKind::Err,
         span: ident.span,
         id: ast::DUMMY_NODE_ID
     };
@@ -135,7 +135,7 @@ impl RecoverQPath for Ty {
     fn recovered(qself: Option<QSelf>, path: ast::Path) -> Self {
         Self {
             span: path.span,
-            node: TyKind::Path(qself, path),
+            kind: TyKind::Path(qself, path),
             id: ast::DUMMY_NODE_ID,
         }
     }
@@ -663,7 +663,7 @@ impl<'a> Parser<'a> {
             pprust::ty_to_string(ty)
         );
 
-        match ty.node {
+        match ty.kind {
             TyKind::Rptr(ref lifetime, ref mut_ty) => {
                 let sum_with_parens = pprust::to_string(|s| {
                     s.s.word("&");
@@ -1296,7 +1296,7 @@ impl<'a> Parser<'a> {
         is_trait_item: bool,
     ) -> PResult<'a, ast::Param> {
         let sp = param.pat.span;
-        param.ty.node = TyKind::Err;
+        param.ty.kind = TyKind::Err;
         let mut err = self.struct_span_err(sp, "unexpected `self` parameter in function");
         if is_trait_item {
             err.span_label(sp, "must be the first associated function parameter");
@@ -1360,7 +1360,7 @@ impl<'a> Parser<'a> {
         let mut seen_inputs = FxHashSet::default();
         for input in fn_inputs.iter_mut() {
             let opt_ident = if let (PatKind::Ident(_, ident, _), TyKind::Err) = (
-                &input.pat.kind, &input.ty.node,
+                &input.pat.kind, &input.ty.kind,
             ) {
                 Some(*ident)
             } else {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index b2b6504919e..cc582819b6b 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1212,7 +1212,7 @@ impl<'a> Parser<'a> {
                 do_not_enforce_named_arguments_for_c_variadic
             ) {
                 Ok(param) => {
-                    if let TyKind::CVarArgs = param.ty.node {
+                    if let TyKind::CVarArgs = param.ty.kind {
                         c_variadic = true;
                         if p.token != token::CloseDelim(token::Paren) {
                             let span = p.token.span;
diff --git a/src/libsyntax/parse/parser/expr.rs b/src/libsyntax/parse/parser/expr.rs
index deb2140f797..c776704b285 100644
--- a/src/libsyntax/parse/parser/expr.rs
+++ b/src/libsyntax/parse/parser/expr.rs
@@ -555,7 +555,7 @@ impl<'a> Parser<'a> {
                         let span_after_type = parser_snapshot_after_type.token.span;
                         let expr = mk_expr(self, P(Ty {
                             span: path.span,
-                            node: TyKind::Path(None, path),
+                            kind: TyKind::Path(None, path),
                             id: DUMMY_NODE_ID,
                         }));
 
@@ -1190,7 +1190,7 @@ impl<'a> Parser<'a> {
         } else {
             P(Ty {
                 id: DUMMY_NODE_ID,
-                node: TyKind::Infer,
+                kind: TyKind::Infer,
                 span: self.prev_span,
             })
         };
diff --git a/src/libsyntax/parse/parser/item.rs b/src/libsyntax/parse/parser/item.rs
index e96d35e1999..27b0325db12 100644
--- a/src/libsyntax/parse/parser/item.rs
+++ b/src/libsyntax/parse/parser/item.rs
@@ -678,7 +678,7 @@ impl<'a> Parser<'a> {
                           self.look_ahead(1, |t| t != &token::Lt) {
             let span = self.prev_span.between(self.token.span);
             self.struct_span_err(span, "missing trait in a trait impl").emit();
-            P(Ty { node: TyKind::Path(None, err_path(span)), span, id: DUMMY_NODE_ID })
+            P(Ty { kind: TyKind::Path(None, err_path(span)), span, id: DUMMY_NODE_ID })
         } else {
             self.parse_ty()?
         };
@@ -715,7 +715,7 @@ impl<'a> Parser<'a> {
                 }
 
                 let ty_first = ty_first.into_inner();
-                let path = match ty_first.node {
+                let path = match ty_first.kind {
                     // This notably includes paths passed through `ty` macro fragments (#46438).
                     TyKind::Path(None, path) => path,
                     _ => {
@@ -1526,7 +1526,7 @@ impl<'a> Parser<'a> {
         // The user intended that the type be inferred,
         // so treat this as if the user wrote e.g. `const A: _ = expr;`.
         P(Ty {
-            node: TyKind::Infer,
+            kind: TyKind::Infer,
             span: id.span,
             id: ast::DUMMY_NODE_ID,
         })
diff --git a/src/libsyntax/parse/parser/ty.rs b/src/libsyntax/parse/parser/ty.rs
index 5697edd8e48..b4c006ca2b1 100644
--- a/src/libsyntax/parse/parser/ty.rs
+++ b/src/libsyntax/parse/parser/ty.rs
@@ -55,7 +55,7 @@ impl<'a> Parser<'a> {
 
         let lo = self.token.span;
         let mut impl_dyn_multi = false;
-        let node = if self.eat(&token::OpenDelim(token::Paren)) {
+        let kind = if self.eat(&token::OpenDelim(token::Paren)) {
             // `(TYPE)` is a parenthesized type.
             // `(TYPE,)` is a tuple with a single field of type TYPE.
             let mut ts = vec![];
@@ -75,7 +75,7 @@ impl<'a> Parser<'a> {
             if ts.len() == 1 && !last_comma {
                 let ty = ts.into_iter().nth(0).unwrap().into_inner();
                 let maybe_bounds = allow_plus && self.token.is_like_plus();
-                match ty.node {
+                match ty.kind {
                     // `(TY_BOUND_NOPAREN) + BOUND + ...`.
                     TyKind::Path(None, ref path) if maybe_bounds => {
                         self.parse_remaining_bounds(Vec::new(), path.clone(), lo, true)?
@@ -211,7 +211,7 @@ impl<'a> Parser<'a> {
         };
 
         let span = lo.to(self.prev_span);
-        let ty = P(Ty { node, span, id: ast::DUMMY_NODE_ID });
+        let ty = P(Ty { kind, span, id: ast::DUMMY_NODE_ID });
 
         // Try to recover from use of `+` with incorrect priority.
         self.maybe_report_ambiguous_plus(allow_plus, impl_dyn_multi, &ty);