Rename FnKind variants and stop re-exporting them from the visit module.

Ms2ger · Ms2ger · commit 2076cddcf235 · 2015-08-26T12:02:58.000+02:00
There is no longer a need for that pattern, since enums are now qualified.
diff --git a/src/librustc/ast_map/blocks.rs b/src/librustc/ast_map/blocks.rs
@@ -28,7 +28,7 @@ use syntax::abi;
 use syntax::ast::{Block, FnDecl, NodeId};
 use syntax::ast;
 use syntax::codemap::Span;
-use syntax::visit;
+use syntax::visit::FnKind;
 
 /// An FnLikeNode is a Node that is like a fn, in that it has a decl
 /// and a body (as well as a NodeId, a span, etc).
@@ -50,7 +50,7 @@ pub trait MaybeFnLike { fn is_fn_like(&self) -> bool; }
 pub struct FnParts<'a> {
     pub decl: &'a FnDecl,
     pub body: &'a Block,
-    pub kind: visit::FnKind<'a>,
+    pub kind: FnKind<'a>,
     pub span: Span,
     pub id:   NodeId,
 }
@@ -186,15 +186,15 @@ impl<'a> FnLikeNode<'a> {
                     |c: ClosureParts|    c.id)
     }
 
-    pub fn kind(self) -> visit::FnKind<'a> {
-        let item = |p: ItemFnParts<'a>| -> visit::FnKind<'a> {
-            visit::FkItemFn(p.ident, p.generics, p.unsafety, p.constness, p.abi, p.vis)
+    pub fn kind(self) -> FnKind<'a> {
+        let item = |p: ItemFnParts<'a>| -> FnKind<'a> {
+            FnKind::ItemFn(p.ident, p.generics, p.unsafety, p.constness, p.abi, p.vis)
         };
         let closure = |_: ClosureParts| {
-            visit::FkClosure
+            FnKind::Closure
         };
         let method = |_, ident, sig: &'a ast::MethodSig, vis, _, _| {
-            visit::FkMethod(ident, sig, vis)
+            FnKind::Method(ident, sig, vis)
         };
         self.handle(item, method, closure)
     }
diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs
@@ -38,7 +38,7 @@ use util::nodemap::NodeMap;
 
 use syntax::ast;
 use syntax::codemap::Span;
-use syntax::visit::{self, Visitor};
+use syntax::visit::{self, FnKind, Visitor};
 
 use std::collections::hash_map::Entry;
 use std::cmp::Ordering;
@@ -142,7 +142,7 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
     }
 
     fn fn_like(&mut self,
-               fk: visit::FnKind,
+               fk: FnKind,
                fd: &ast::FnDecl,
                b: &ast::Block,
                s: Span,
@@ -157,10 +157,10 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
         }
 
         let mode = match fk {
-            visit::FkItemFn(_, _, _, ast::Constness::Const, _, _) => {
+            FnKind::ItemFn(_, _, _, ast::Constness::Const, _, _) => {
                 Mode::ConstFn
             }
-            visit::FkMethod(_, m, _) => {
+            FnKind::Method(_, m, _) => {
                 if m.constness == ast::Constness::Const {
                     Mode::ConstFn
                 } else {
@@ -352,7 +352,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
     }
 
     fn visit_fn(&mut self,
-                fk: visit::FnKind<'v>,
+                fk: FnKind<'v>,
                 fd: &'v ast::FnDecl,
                 b: &'v ast::Block,
                 s: Span,
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
@@ -1007,7 +1007,7 @@ fn check_fn(cx: &mut MatchCheckCtxt,
             sp: Span,
             fn_id: NodeId) {
     match kind {
-        visit::FkClosure => {}
+        FnKind::Closure => {}
         _ => cx.param_env = ParameterEnvironment::for_item(cx.tcx, fn_id),
     }
 
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![allow(non_camel_case_types)]
+//#![allow(non_camel_case_types)]
 
 use self::ConstVal::*;
 use self::ErrKind::*;
@@ -26,10 +26,10 @@ use middle::astconv_util::ast_ty_to_prim_ty;
 use util::num::ToPrimitive;
 
 use syntax::ast::{self, Expr};
-use syntax::codemap::Span;
+use syntax::codemap::{self, Span};
 use syntax::parse::token::InternedString;
 use syntax::ptr::P;
-use syntax::{codemap, visit};
+use syntax::visit::FnKind;
 
 use std::borrow::{Cow, IntoCow};
 use std::num::wrapping::OverflowingOps;
@@ -246,10 +246,10 @@ pub fn lookup_const_fn_by_id<'tcx>(tcx: &ty::ctxt<'tcx>, def_id: DefId)
     };
 
     match fn_like.kind() {
-        visit::FkItemFn(_, _, _, ast::Constness::Const, _, _) => {
+        FnKind::ItemFn(_, _, _, ast::Constness::Const, _, _) => {
             Some(fn_like)
         }
-        visit::FkMethod(_, m, _) => {
+        FnKind::Method(_, m, _) => {
             if m.constness == ast::Constness::Const {
                 Some(fn_like)
             } else {
diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs
@@ -19,7 +19,7 @@ use middle::ty::MethodCall;
 use syntax::ast;
 use syntax::codemap::Span;
 use syntax::visit;
-use syntax::visit::Visitor;
+use syntax::visit::{FnKind, Visitor};
 
 #[derive(Copy, Clone)]
 struct UnsafeContext {
@@ -75,13 +75,13 @@ impl<'a, 'tcx> EffectCheckVisitor<'a, 'tcx> {
 }
 
 impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> {
-    fn visit_fn(&mut self, fn_kind: visit::FnKind<'v>, fn_decl: &'v ast::FnDecl,
+    fn visit_fn(&mut self, fn_kind: FnKind<'v>, fn_decl: &'v ast::FnDecl,
                 block: &'v ast::Block, span: Span, _: ast::NodeId) {
 
         let (is_item_fn, is_unsafe_fn) = match fn_kind {
-            visit::FkItemFn(_, _, unsafety, _, _, _) =>
+            FnKind::ItemFn(_, _, unsafety, _, _, _) =>
                 (true, unsafety == ast::Unsafety::Unsafe),
-            visit::FkMethod(_, sig, _) =>
+            FnKind::Method(_, sig, _) =>
                 (true, sig.unsafety == ast::Unsafety::Unsafe),
             _ => (false, false),
         };
diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs
@@ -19,7 +19,7 @@ use std::fmt;
 use syntax::abi::RustIntrinsic;
 use syntax::ast;
 use syntax::codemap::Span;
-use syntax::visit::Visitor;
+use syntax::visit::{FnKind, Visitor};
 use syntax::visit;
 
 pub fn check_crate(tcx: &ctxt) {
@@ -216,16 +216,16 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> {
 }
 
 impl<'a, 'tcx, 'v> Visitor<'v> for IntrinsicCheckingVisitor<'a, 'tcx> {
-    fn visit_fn(&mut self, fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+    fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v ast::FnDecl,
                 b: &'v ast::Block, s: Span, id: ast::NodeId) {
         match fk {
-            visit::FkItemFn(..) | visit::FkMethod(..) => {
+            FnKind::ItemFn(..) | FnKind::Method(..) => {
                 let param_env = ty::ParameterEnvironment::for_item(self.tcx, id);
                 self.param_envs.push(param_env);
                 visit::walk_fn(self, fk, fd, b, s);
                 self.param_envs.pop();
             }
-            visit::FkClosure(..) => {
+            FnKind::Closure(..) => {
                 visit::walk_fn(self, fk, fd, b, s);
             }
         }
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
@@ -30,7 +30,7 @@ use syntax::codemap::Span;
 use syntax::parse::token::special_idents;
 use syntax::print::pprust::lifetime_to_string;
 use syntax::visit;
-use syntax::visit::Visitor;
+use syntax::visit::{FnKind, Visitor};
 use util::nodemap::NodeMap;
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)]
@@ -173,20 +173,20 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {
         replace(&mut self.labels_in_fn, saved);
     }
 
-    fn visit_fn(&mut self, fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+    fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v ast::FnDecl,
                 b: &'v ast::Block, s: Span, _: ast::NodeId) {
         match fk {
-            visit::FkItemFn(_, generics, _, _, _, _) => {
+            FnKind::ItemFn(_, generics, _, _, _, _) => {
                 self.visit_early_late(subst::FnSpace, generics, |this| {
                     this.walk_fn(fk, fd, b, s)
                 })
             }
-            visit::FkMethod(_, sig, _) => {
+            FnKind::Method(_, sig, _) => {
                 self.visit_early_late(subst::FnSpace, &sig.generics, |this| {
                     this.walk_fn(fk, fd, b, s)
                 })
             }
-            visit::FkClosure(..) => {
+            FnKind::Closure(..) => {
                 self.walk_fn(fk, fd, b, s)
             }
         }
@@ -470,21 +470,21 @@ impl<'a> LifetimeContext<'a> {
     // labels of the function body and swaps them in before visiting
     // the function body itself.
     fn walk_fn<'b>(&mut self,
-                   fk: visit::FnKind,
+                   fk: FnKind,
                    fd: &ast::FnDecl,
                    fb: &'b ast::Block,
                    _span: Span) {
         match fk {
-            visit::FkItemFn(_, generics, _, _, _, _) => {
+            FnKind::ItemFn(_, generics, _, _, _, _) => {
                 visit::walk_fn_decl(self, fd);
                 self.visit_generics(generics);
             }
-            visit::FkMethod(_, sig, _) => {
+            FnKind::Method(_, sig, _) => {
                 visit::walk_fn_decl(self, fd);
                 self.visit_generics(&sig.generics);
                 self.visit_explicit_self(&sig.explicit_self);
             }
-            visit::FkClosure(..) => {
+            FnKind::Closure(..) => {
                 visit::walk_fn_decl(self, fd);
             }
         }
diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs
@@ -59,16 +59,16 @@ impl<'a, 'tcx, 'v> Visitor<'v> for BorrowckCtxt<'a, 'tcx> {
     fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
                 b: &'v Block, s: Span, id: ast::NodeId) {
         match fk {
-            visit::FkItemFn(..) |
-            visit::FkMethod(..) => {
+            FnKind::ItemFn(..) |
+            FnKind::Method(..) => {
                 let new_free_region_map = self.tcx.free_region_map(id);
                 let old_free_region_map =
                     mem::replace(&mut self.free_region_map, new_free_region_map);
                 borrowck_fn(self, fk, fd, b, s, id);
                 self.free_region_map = old_free_region_map;
             }
 
-            visit::FkClosure => {
+            FnKind::Closure => {
                 borrowck_fn(self, fk, fd, b, s, id);
             }
         }
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -51,7 +51,7 @@ use syntax::codemap::{self, Span};
 use syntax::feature_gate::{KNOWN_ATTRIBUTES, AttributeType};
 use syntax::ast::{TyIs, TyUs, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64};
 use syntax::ptr::P;
-use syntax::visit::{self, Visitor};
+use syntax::visit::{self, FnKind, Visitor};
 
 // hardwired lints from librustc
 pub use lint::builtin::*;
@@ -1240,10 +1240,10 @@ impl LintPass for NonSnakeCase {
     }
 
     fn check_fn(&mut self, cx: &Context,
-                fk: visit::FnKind, _: &ast::FnDecl,
+                fk: FnKind, _: &ast::FnDecl,
                 _: &ast::Block, span: Span, id: ast::NodeId) {
         match fk {
-            visit::FkMethod(ident, _, _) => match method_context(cx, id, span) {
+            FnKind::Method(ident, _, _) => match method_context(cx, id, span) {
                 MethodContext::PlainImpl => {
                     self.check_snake_case(cx, "method", &ident.name.as_str(), Some(span))
                 },
@@ -1252,7 +1252,7 @@ impl LintPass for NonSnakeCase {
                 },
                 _ => (),
             },
-            visit::FkItemFn(ident, _, _, _, _, _) => {
+            FnKind::ItemFn(ident, _, _, _, _, _) => {
                 self.check_snake_case(cx, "function", &ident.name.as_str(), Some(span))
             },
             _ => (),
@@ -1598,13 +1598,13 @@ impl LintPass for UnsafeCode {
         }
     }
 
-    fn check_fn(&mut self, cx: &Context, fk: visit::FnKind, _: &ast::FnDecl,
+    fn check_fn(&mut self, cx: &Context, fk: FnKind, _: &ast::FnDecl,
                 _: &ast::Block, span: Span, _: ast::NodeId) {
         match fk {
-            visit::FkItemFn(_, _, ast::Unsafety::Unsafe, _, _, _) =>
+            FnKind::ItemFn(_, _, ast::Unsafety::Unsafe, _, _, _) =>
                 cx.span_lint(UNSAFE_CODE, span, "declaration of an `unsafe` function"),
 
-            visit::FkMethod(_, sig, _) => {
+            FnKind::Method(_, sig, _) => {
                 if sig.unsafety == ast::Unsafety::Unsafe {
                     cx.span_lint(UNSAFE_CODE, span, "implementation of an `unsafe` method")
                 }
@@ -1685,7 +1685,7 @@ impl LintPass for UnusedMut {
     }
 
     fn check_fn(&mut self, cx: &Context,
-                _: visit::FnKind, decl: &ast::FnDecl,
+                _: FnKind, decl: &ast::FnDecl,
                 _: &ast::Block, _: Span, _: ast::NodeId) {
         for a in &decl.inputs {
             self.check_unused_mut_pat(cx, slice::ref_slice(&a.pat));
@@ -2126,18 +2126,18 @@ impl LintPass for UnconditionalRecursion {
         lint_array![UNCONDITIONAL_RECURSION]
     }
 
-    fn check_fn(&mut self, cx: &Context, fn_kind: visit::FnKind, _: &ast::FnDecl,
+    fn check_fn(&mut self, cx: &Context, fn_kind: FnKind, _: &ast::FnDecl,
                 blk: &ast::Block, sp: Span, id: ast::NodeId) {
         type F = for<'tcx> fn(&ty::ctxt<'tcx>,
                               ast::NodeId, ast::NodeId, ast::Ident, ast::NodeId) -> bool;
 
         let method = match fn_kind {
-            visit::FkItemFn(..) => None,
-            visit::FkMethod(..) => {
+            FnKind::ItemFn(..) => None,
+            FnKind::Method(..) => {
                 cx.tcx.impl_or_trait_item(DefId::local(id)).as_opt_method()
             }
             // closures can't recur, so they don't matter.
-            visit::FkClosure => return
+            FnKind::Closure => return
         };
 
         // Walk through this function (say `f`) looking to see if
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
@@ -88,7 +88,7 @@ use syntax::ext::mtwt;
 use syntax::parse::token::{self, special_names, special_idents};
 use syntax::ptr::P;
 use syntax::codemap::{self, Span, Pos};
-use syntax::visit::{self, Visitor};
+use syntax::visit::{self, FnKind, Visitor};
 
 use std::collections::{HashMap, HashSet};
 use std::collections::hash_map::Entry::{Occupied, Vacant};
@@ -527,22 +527,22 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> {
         });
     }
     fn visit_fn(&mut self,
-                function_kind: visit::FnKind<'v>,
+                function_kind: FnKind<'v>,
                 declaration: &'v FnDecl,
                 block: &'v Block,
                 _: Span,
                 node_id: NodeId) {
         let rib_kind = match function_kind {
-            visit::FkItemFn(_, generics, _, _, _, _) => {
+            FnKind::ItemFn(_, generics, _, _, _, _) => {
                 self.visit_generics(generics);
                 ItemRibKind
             }
-            visit::FkMethod(_, sig, _) => {
+            FnKind::Method(_, sig, _) => {
                 self.visit_generics(&sig.generics);
                 self.visit_explicit_self(&sig.explicit_self);
                 MethodRibKind
             }
-            visit::FkClosure(..) => ClosureRibKind(node_id)
+            FnKind::Closure(..) => ClosureRibKind(node_id)
         };
         self.resolve_function(rib_kind, declaration, block);
     }
diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs
@@ -25,7 +25,7 @@ use syntax::ast;
 use syntax::codemap::{DUMMY_SP, Span};
 use syntax::parse::token::{special_idents};
 use syntax::visit;
-use syntax::visit::Visitor;
+use syntax::visit::{FnKind, Visitor};
 
 pub struct CheckTypeWellFormedVisitor<'ccx, 'tcx:'ccx> {
     ccx: &'ccx CrateCtxt<'ccx, 'tcx>,
@@ -425,11 +425,11 @@ impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> {
     }
 
     fn visit_fn(&mut self,
-                fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+                fk: FnKind<'v>, fd: &'v ast::FnDecl,
                 b: &'v ast::Block, span: Span, id: ast::NodeId) {
         match fk {
-            visit::FkClosure | visit::FkItemFn(..) => {}
-            visit::FkMethod(..) => {
+            FnKind::Closure | FnKind::ItemFn(..) => {}
+            FnKind::Method(..) => {
                 match self.tcx().impl_or_trait_item(DefId::local(id)) {
                     ty::ImplOrTraitItem::MethodTraitItem(ty_method) => {
                         reject_shadowing_type_parameters(self.tcx(), span, &ty_method.generics)
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs

Original file line number	Diff line number	Diff line change
`@@ -1007,7 +1007,7 @@ fn check_fn(cx: &mut MatchCheckCtxt,`
`1007`	`1007`	`sp: Span,`
`1008`	`1008`	`fn_id: NodeId) {`
`1009`	`1009`	`match kind {`
`1010`		`- visit::FkClosure => {}`
	`1010`	`+ FnKind::Closure => {}`
`1011`	`1011`	`_ => cx.param_env = ParameterEnvironment::for_item(cx.tcx, fn_id),`
`1012`	`1012`	`}`
`1013`	`1013`
Original file line number	Diff line number	Diff line change
`@@ -59,16 +59,16 @@ impl<'a, 'tcx, 'v> Visitor<'v> for BorrowckCtxt<'a, 'tcx> {`
`59`	`59`	`fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,`
`60`	`60`	`b: &'v Block, s: Span, id: ast::NodeId) {`
`61`	`61`	`match fk {`
`62`		`- visit::FkItemFn(..) \|`
`63`		`- visit::FkMethod(..) => {`
	`62`	`+ FnKind::ItemFn(..) \|`
	`63`	`+ FnKind::Method(..) => {`
`64`	`64`	`let new_free_region_map = self.tcx.free_region_map(id);`
`65`	`65`	`let old_free_region_map =`
`66`	`66`	`mem::replace(&mut self.free_region_map, new_free_region_map);`
`67`	`67`	`borrowck_fn(self, fk, fd, b, s, id);`
`68`	`68`	`self.free_region_map = old_free_region_map;`
`69`	`69`	`}`
`70`	`70`
`71`		`- visit::FkClosure => {`
	`71`	`+ FnKind::Closure => {`
`72`	`72`	`borrowck_fn(self, fk, fd, b, s, id);`
`73`	`73`	`}`
`74`	`74`	`}`