Unify assoc item visitors more.

Centril · Centril · commit b499a88dfc48 · 2019-12-12T18:01:33.000+01:00
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -484,19 +484,19 @@ impl<'a> LoweringContext<'a> {
                     TraitItemKind::Method(_, None) => {
                         // Ignore patterns in trait methods without bodies
                         self.with_hir_id_owner(None, |this| {
-                            visit::walk_assoc_item(this, item)
+                            visit::walk_trait_item(this, item)
                         });
                     }
                     _ => self.with_hir_id_owner(Some(item.id), |this| {
-                        visit::walk_assoc_item(this, item);
+                        visit::walk_trait_item(this, item);
                     })
                 }
             }
 
             fn visit_impl_item(&mut self, item: &'tcx ImplItem) {
                 self.lctx.allocate_hir_id_counter(item.id);
                 self.with_hir_id_owner(Some(item.id), |this| {
-                    visit::walk_assoc_item(this, item);
+                    visit::walk_impl_item(this, item);
                 });
             }
 
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
@@ -1252,15 +1252,15 @@ impl<'a, T: EarlyLintPass> ast_visit::Visitor<'a> for EarlyContextAndPass<'a, T>
     fn visit_trait_item(&mut self, trait_item: &'a ast::TraitItem) {
         self.with_lint_attrs(trait_item.id, &trait_item.attrs, |cx| {
             run_early_pass!(cx, check_trait_item, trait_item);
-            ast_visit::walk_assoc_item(cx, trait_item);
+            ast_visit::walk_trait_item(cx, trait_item);
             run_early_pass!(cx, check_trait_item_post, trait_item);
         });
     }
 
     fn visit_impl_item(&mut self, impl_item: &'a ast::ImplItem) {
         self.with_lint_attrs(impl_item.id, &impl_item.attrs, |cx| {
             run_early_pass!(cx, check_impl_item, impl_item);
-            ast_visit::walk_assoc_item(cx, impl_item);
+            ast_visit::walk_impl_item(cx, impl_item);
             run_early_pass!(cx, check_impl_item_post, impl_item);
         });
     }
diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs
@@ -787,13 +787,13 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
             }
             _ => {}
         }
-        visit::walk_assoc_item(self, ii);
+        visit::walk_impl_item(self, ii);
     }
 
     fn visit_trait_item(&mut self, ti: &'a AssocItem) {
         self.invalid_visibility(&ti.vis, None);
         self.check_defaultness(ti.span, ti.defaultness);
-        visit::walk_assoc_item(self, ti);
+        visit::walk_trait_item(self, ti);
     }
 }
 
diff --git a/src/librustc_passes/hir_stats.rs b/src/librustc_passes/hir_stats.rs
@@ -316,12 +316,12 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
 
     fn visit_trait_item(&mut self, ti: &'v ast::TraitItem) {
         self.record("TraitItem", Id::None, ti);
-        ast_visit::walk_assoc_item(self, ti)
+        ast_visit::walk_trait_item(self, ti)
     }
 
     fn visit_impl_item(&mut self, ii: &'v ast::ImplItem) {
         self.record("ImplItem", Id::None, ii);
-        ast_visit::walk_assoc_item(self, ii)
+        ast_visit::walk_impl_item(self, ii)
     }
 
     fn visit_param_bound(&mut self, bounds: &'v ast::GenericBound) {
diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
@@ -1190,15 +1190,15 @@ impl<'a, 'b> Visitor<'b> for BuildReducedGraphVisitor<'a, 'b> {
         let expansion = self.parent_scope.expansion;
         self.r.define(parent, item.ident, ns, (res, vis, item.span, expansion));
 
-        visit::walk_assoc_item(self, item);
+        visit::walk_trait_item(self, item);
     }
 
     fn visit_impl_item(&mut self, item: &'b ast::ImplItem) {
         if let ast::ImplItemKind::Macro(..) = item.kind {
             self.visit_invoc(item.id);
         } else {
             self.resolve_visibility(&item.vis);
-            visit::walk_assoc_item(self, item);
+            visit::walk_impl_item(self, item);
         }
     }
 
diff --git a/src/librustc_resolve/def_collector.rs b/src/librustc_resolve/def_collector.rs
@@ -223,7 +223,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
         };
 
         let def = self.create_def(ti.id, def_data, ti.span);
-        self.with_parent(def, |this| visit::walk_assoc_item(this, ti));
+        self.with_parent(def, |this| visit::walk_trait_item(this, ti));
     }
 
     fn visit_impl_item(&mut self, ii: &'a ImplItem) {
@@ -249,7 +249,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
         };
 
         let def = self.create_def(ii.id, def_data, ii.span);
-        self.with_parent(def, |this| visit::walk_assoc_item(this, ii));
+        self.with_parent(def, |this| visit::walk_impl_item(this, ii));
     }
 
     fn visit_pat(&mut self, pat: &'a Pat) {
diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
@@ -577,42 +577,38 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 if block.is_none() {
                     self.check_extern(sig.header.ext);
                 }
-                if sig.decl.c_variadic() {
-                    gate_feature_post!(&self, c_variadic, ti.span,
-                                       "C-variadic functions are unstable");
-                }
                 if sig.header.constness.node == ast::Constness::Const {
                     gate_feature_post!(&self, const_fn, ti.span, "const fn is unstable");
                 }
             }
             ast::TraitItemKind::TyAlias(_, ref default) => {
-                if let Some(ty) = default {
-                    self.check_impl_trait(ty);
-                    gate_feature_post!(&self, associated_type_defaults, ti.span,
-                                       "associated type defaults are unstable");
+                if let Some(_) = default {
+                    gate_feature_post!(
+                        &self, associated_type_defaults, ti.span,
+                        "associated type defaults are unstable"
+                    );
                 }
-                self.check_gat(&ti.generics, ti.span);
             }
             _ => {}
         }
-        visit::walk_assoc_item(self, ti)
+        visit::walk_trait_item(self, ti)
     }
 
-    fn visit_impl_item(&mut self, ii: &'a ast::ImplItem) {
+    fn visit_assoc_item(&mut self, ii: &'a ast::AssocItem) {
         if ii.defaultness == ast::Defaultness::Default {
-            gate_feature_post!(&self, specialization,
-                              ii.span,
-                              "specialization is unstable");
+            gate_feature_post!(&self, specialization, ii.span, "specialization is unstable");
         }
 
         match ii.kind {
-            ast::ImplItemKind::Method(ref sig, _) => {
+            ast::AssocItemKind::Method(ref sig, _) => {
                 if sig.decl.c_variadic() {
-                    gate_feature_post!(&self, c_variadic, ii.span,
-                                       "C-variadic functions are unstable");
+                    gate_feature_post!(
+                        &self, c_variadic, ii.span,
+                        "C-variadic functions are unstable"
+                    );
                 }
             }
-            ast::ImplItemKind::TyAlias(_, ref ty) => {
+            ast::AssocItemKind::TyAlias(_, ref ty) => {
                 if let Some(ty) = ty {
                     self.check_impl_trait(ty);
                 }
diff --git a/src/libsyntax/util/node_count.rs b/src/libsyntax/util/node_count.rs
@@ -73,14 +73,10 @@ impl<'ast> Visitor<'ast> for NodeCounter {
         self.count += 1;
         walk_fn(self, fk, fd, s)
     }
-    fn visit_trait_item(&mut self, ti: &TraitItem) {
+    fn visit_assoc_item(&mut self, ti: &AssocItem) {
         self.count += 1;
         walk_assoc_item(self, ti)
     }
-    fn visit_impl_item(&mut self, ii: &ImplItem) {
-        self.count += 1;
-        walk_assoc_item(self, ii)
-    }
     fn visit_trait_ref(&mut self, t: &TraitRef) {
         self.count += 1;
         walk_trait_ref(self, t)
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
@@ -83,8 +83,9 @@ pub trait Visitor<'ast>: Sized {
     fn visit_fn(&mut self, fk: FnKind<'ast>, fd: &'ast FnDecl, s: Span, _: NodeId) {
         walk_fn(self, fk, fd, s)
     }
-    fn visit_trait_item(&mut self, i: &'ast AssocItem) { walk_assoc_item(self, i) }
-    fn visit_impl_item(&mut self, i: &'ast AssocItem) { walk_assoc_item(self, i) }
+    fn visit_trait_item(&mut self, i: &'ast AssocItem) { walk_trait_item(self, i) }
+    fn visit_impl_item(&mut self, i: &'ast AssocItem) { walk_impl_item(self, i) }
+    fn visit_assoc_item(&mut self, i: &'ast AssocItem) { walk_assoc_item(self, i) }
     fn visit_trait_ref(&mut self, t: &'ast TraitRef) { walk_trait_ref(self, t) }
     fn visit_param_bound(&mut self, bounds: &'ast GenericBound) {
         walk_param_bound(self, bounds)
@@ -581,6 +582,14 @@ pub fn walk_fn<'a, V>(visitor: &mut V, kind: FnKind<'a>, declaration: &'a FnDecl
     }
 }
 
+pub fn walk_impl_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a AssocItem) {
+    visitor.visit_assoc_item(item);
+}
+
+pub fn walk_trait_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a AssocItem) {
+    visitor.visit_assoc_item(item);
+}
+
 pub fn walk_assoc_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a AssocItem) {
     visitor.visit_vis(&item.vis);
     visitor.visit_ident(item.ident);
diff --git a/src/test/ui/feature-gates/feature-gate-type_alias_impl_trait.stderr b/src/test/ui/feature-gates/feature-gate-type_alias_impl_trait.stderr
@@ -16,15 +16,6 @@ LL |     type Baa = impl Debug;
    = note: for more information, see https://github.com/rust-lang/rust/issues/63063
    = help: add `#![feature(type_alias_impl_trait)]` to the crate attributes to enable
 
-error[E0658]: `impl Trait` in type aliases is unstable
-  --> $DIR/feature-gate-type_alias_impl_trait.rs:18:18
-   |
-LL |     type Assoc = impl Debug;
-   |                  ^^^^^^^^^^
-   |
-   = note: for more information, see https://github.com/rust-lang/rust/issues/63063
-   = help: add `#![feature(type_alias_impl_trait)]` to the crate attributes to enable
-
 error[E0658]: associated type defaults are unstable
   --> $DIR/feature-gate-type_alias_impl_trait.rs:18:5
    |
@@ -34,6 +25,15 @@ LL |     type Assoc = impl Debug;
    = note: for more information, see https://github.com/rust-lang/rust/issues/29661
    = help: add `#![feature(associated_type_defaults)]` to the crate attributes to enable
 
+error[E0658]: `impl Trait` in type aliases is unstable
+  --> $DIR/feature-gate-type_alias_impl_trait.rs:18:18
+   |
+LL |     type Assoc = impl Debug;
+   |                  ^^^^^^^^^^
+   |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/63063
+   = help: add `#![feature(type_alias_impl_trait)]` to the crate attributes to enable
+
 error[E0658]: `impl Trait` in type aliases is unstable
   --> $DIR/feature-gate-type_alias_impl_trait.rs:24:24
    |
diff --git a/src/test/ui/parser/trait-item-with-defaultness-fail-semantic.rs b/src/test/ui/parser/trait-item-with-defaultness-fail-semantic.rs
@@ -1,3 +1,5 @@
+#![feature(specialization)]
+
 fn main() {}
 
 trait X {
diff --git a/src/test/ui/parser/trait-item-with-defaultness-fail-semantic.stderr b/src/test/ui/parser/trait-item-with-defaultness-fail-semantic.stderr
@@ -1,35 +1,35 @@
 error: `default` is only allowed on items in `impl` definitions
-  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:4:5
+  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:6:5
    |
 LL |     default const A: u8;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: `default` is only allowed on items in `impl` definitions
-  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:5:5
+  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:7:5
    |
 LL |     default const B: u8 = 0;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `default` is only allowed on items in `impl` definitions
-  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:6:5
+  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:8:5
    |
 LL |     default type D;
    |     ^^^^^^^^^^^^^^^
 
 error: `default` is only allowed on items in `impl` definitions
-  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:7:5
+  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:9:5
    |
 LL |     default type C: Ord;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: `default` is only allowed on items in `impl` definitions
-  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:8:5
+  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:10:5
    |
 LL |     default fn f1();
    |     ^^^^^^^^^^^^^^^^
 
 error: `default` is only allowed on items in `impl` definitions
-  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:9:5
+  --> $DIR/trait-item-with-defaultness-fail-semantic.rs:11:5
    |
 LL |     default fn f2() {}
    |     ^^^^^^^^^^^^^^^^^^

Original file line number	Diff line number	Diff line change
`@@ -484,19 +484,19 @@ impl<'a> LoweringContext<'a> {`
`484`	`484`	`TraitItemKind::Method(_, None) => {`
`485`	`485`	`// Ignore patterns in trait methods without bodies`
`486`	`486`	`self.with_hir_id_owner(None, \|this\| {`
`487`		`- visit::walk_assoc_item(this, item)`
	`487`	`+ visit::walk_trait_item(this, item)`
`488`	`488`	`});`
`489`	`489`	`}`
`490`	`490`	`_ => self.with_hir_id_owner(Some(item.id), \|this\| {`
`491`		`- visit::walk_assoc_item(this, item);`
	`491`	`+ visit::walk_trait_item(this, item);`
`492`	`492`	`})`
`493`	`493`	`}`
`494`	`494`	`}`
`495`	`495`
`496`	`496`	`fn visit_impl_item(&mut self, item: &'tcx ImplItem) {`
`497`	`497`	`self.lctx.allocate_hir_id_counter(item.id);`
`498`	`498`	`self.with_hir_id_owner(Some(item.id), \|this\| {`
`499`		`- visit::walk_assoc_item(this, item);`
	`499`	`+ visit::walk_impl_item(this, item);`
`500`	`500`	`});`
`501`	`501`	`}`
`502`	`502`
Original file line number	Diff line number	Diff line change
`@@ -787,13 +787,13 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`787`	`787`	`}`
`788`	`788`	`_ => {}`
`789`	`789`	`}`
`790`		`- visit::walk_assoc_item(self, ii);`
	`790`	`+ visit::walk_impl_item(self, ii);`
`791`	`791`	`}`
`792`	`792`
`793`	`793`	`fn visit_trait_item(&mut self, ti: &'a AssocItem) {`
`794`	`794`	`self.invalid_visibility(&ti.vis, None);`
`795`	`795`	`self.check_defaultness(ti.span, ti.defaultness);`
`796`		`- visit::walk_assoc_item(self, ti);`
	`796`	`+ visit::walk_trait_item(self, ti);`
`797`	`797`	`}`
`798`	`798`	`}`
`799`	`799`
Original file line number	Diff line number	Diff line change
`@@ -316,12 +316,12 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {`
`316`	`316`
`317`	`317`	`fn visit_trait_item(&mut self, ti: &'v ast::TraitItem) {`
`318`	`318`	`self.record("TraitItem", Id::None, ti);`
`319`		`- ast_visit::walk_assoc_item(self, ti)`
	`319`	`+ ast_visit::walk_trait_item(self, ti)`
`320`	`320`	`}`
`321`	`321`
`322`	`322`	`fn visit_impl_item(&mut self, ii: &'v ast::ImplItem) {`
`323`	`323`	`self.record("ImplItem", Id::None, ii);`
`324`		`- ast_visit::walk_assoc_item(self, ii)`
	`324`	`+ ast_visit::walk_impl_item(self, ii)`
`325`	`325`	`}`
`326`	`326`
`327`	`327`	`fn visit_param_bound(&mut self, bounds: &'v ast::GenericBound) {`
Original file line number	Diff line number	Diff line change
`@@ -1190,15 +1190,15 @@ impl<'a, 'b> Visitor<'b> for BuildReducedGraphVisitor<'a, 'b> {`
`1190`	`1190`	`let expansion = self.parent_scope.expansion;`
`1191`	`1191`	`self.r.define(parent, item.ident, ns, (res, vis, item.span, expansion));`
`1192`	`1192`
`1193`		`- visit::walk_assoc_item(self, item);`
	`1193`	`+ visit::walk_trait_item(self, item);`
`1194`	`1194`	`}`
`1195`	`1195`
`1196`	`1196`	`fn visit_impl_item(&mut self, item: &'b ast::ImplItem) {`
`1197`	`1197`	`if let ast::ImplItemKind::Macro(..) = item.kind {`
`1198`	`1198`	`self.visit_invoc(item.id);`
`1199`	`1199`	`} else {`
`1200`	`1200`	`self.resolve_visibility(&item.vis);`
`1201`		`- visit::walk_assoc_item(self, item);`
	`1201`	`+ visit::walk_impl_item(self, item);`
`1202`	`1202`	`}`
`1203`	`1203`	`}`
`1204`	`1204`
Original file line number	Diff line number	Diff line change
`@@ -223,7 +223,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {`
`223`	`223`	`};`
`224`	`224`
`225`	`225`	`let def = self.create_def(ti.id, def_data, ti.span);`
`226`		`- self.with_parent(def, \|this\| visit::walk_assoc_item(this, ti));`
	`226`	`+ self.with_parent(def, \|this\| visit::walk_trait_item(this, ti));`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`fn visit_impl_item(&mut self, ii: &'a ImplItem) {`
`@@ -249,7 +249,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {`
`249`	`249`	`};`
`250`	`250`
`251`	`251`	`let def = self.create_def(ii.id, def_data, ii.span);`
`252`		`- self.with_parent(def, \|this\| visit::walk_assoc_item(this, ii));`
	`252`	`+ self.with_parent(def, \|this\| visit::walk_impl_item(this, ii));`
`253`	`253`	`}`
`254`	`254`
`255`	`255`	`fn visit_pat(&mut self, pat: &'a Pat) {`
Original file line number	Diff line number	Diff line change
`@@ -577,42 +577,38 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {`
`577`	`577`	`if block.is_none() {`
`578`	`578`	`self.check_extern(sig.header.ext);`
`579`	`579`	`}`
`580`		`- if sig.decl.c_variadic() {`
`581`		`- gate_feature_post!(&self, c_variadic, ti.span,`
`582`		`- "C-variadic functions are unstable");`
`583`		`- }`
`584`	`580`	`if sig.header.constness.node == ast::Constness::Const {`
`585`	`581`	`gate_feature_post!(&self, const_fn, ti.span, "const fn is unstable");`
`586`	`582`	`}`
`587`	`583`	`}`
`588`	`584`	`ast::TraitItemKind::TyAlias(_, ref default) => {`
`589`		`- if let Some(ty) = default {`
`590`		`- self.check_impl_trait(ty);`
`591`		`- gate_feature_post!(&self, associated_type_defaults, ti.span,`
`592`		`- "associated type defaults are unstable");`
	`585`	`+ if let Some(_) = default {`
	`586`	`+ gate_feature_post!(`
	`587`	`+ &self, associated_type_defaults, ti.span,`
	`588`	`+ "associated type defaults are unstable"`
	`589`	`+ );`
`593`	`590`	`}`
`594`		`- self.check_gat(&ti.generics, ti.span);`
`595`	`591`	`}`
`596`	`592`	`_ => {}`
`597`	`593`	`}`
`598`		`- visit::walk_assoc_item(self, ti)`
	`594`	`+ visit::walk_trait_item(self, ti)`
`599`	`595`	`}`
`600`	`596`
`601`		`- fn visit_impl_item(&mut self, ii: &'a ast::ImplItem) {`
	`597`	`+ fn visit_assoc_item(&mut self, ii: &'a ast::AssocItem) {`
`602`	`598`	`if ii.defaultness == ast::Defaultness::Default {`
`603`		`- gate_feature_post!(&self, specialization,`
`604`		`- ii.span,`
`605`		`- "specialization is unstable");`
	`599`	`+ gate_feature_post!(&self, specialization, ii.span, "specialization is unstable");`
`606`	`600`	`}`
`607`	`601`
`608`	`602`	`match ii.kind {`
`609`		`- ast::ImplItemKind::Method(ref sig, _) => {`
	`603`	`+ ast::AssocItemKind::Method(ref sig, _) => {`
`610`	`604`	`if sig.decl.c_variadic() {`
`611`		`- gate_feature_post!(&self, c_variadic, ii.span,`
`612`		`- "C-variadic functions are unstable");`
	`605`	`+ gate_feature_post!(`
	`606`	`+ &self, c_variadic, ii.span,`
	`607`	`+ "C-variadic functions are unstable"`
	`608`	`+ );`
`613`	`609`	`}`
`614`	`610`	`}`
`615`		`- ast::ImplItemKind::TyAlias(_, ref ty) => {`
	`611`	`+ ast::AssocItemKind::TyAlias(_, ref ty) => {`
`616`	`612`	`if let Some(ty) = ty {`
`617`	`613`	`self.check_impl_trait(ty);`
`618`	`614`	`}`