Stop re-exporting the ast::BindingMode variants.

diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs
index c0b10fb89124a9ba07a173a3ff8c80548f3afb8e..2e66aa56eaf73b820420f348e584d0f0c612cf90 100644 (file)
--- a/src/librustc_front/lowering.rs
+++ b/src/librustc_front/lowering.rs
@@ -1563,8 +1563,8 @@ pub fn lower_block_check_mode(lctx: &LoweringContext, b: &BlockCheckMode) -> hir
 
 pub fn lower_binding_mode(lctx: &LoweringContext, b: &BindingMode) -> hir::BindingMode {
     match *b {
-        BindByRef(m) => hir::BindByRef(lower_mutability(lctx, m)),
-        BindByValue(m) => hir::BindByValue(lower_mutability(lctx, m)),
+        BindingMode::ByRef(m) => hir::BindByRef(lower_mutability(lctx, m)),
+        BindingMode::ByValue(m) => hir::BindByValue(lower_mutability(lctx, m)),
     }
 }
 

diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs
index cc5322d7f9f46c04484caee61af584fae6606507..501ab566f1c5abc2c06afc252f1f54fb6a113deb 100644 (file)
--- a/src/librustc_trans/save/mod.rs
+++ b/src/librustc_trans/save/mod.rs
@@ -697,8 +697,8 @@ fn visit_pat(&mut self, p: &ast::Pat) {
                     // Even if the ref is mut, you can't change the ref, only
                     // the data pointed at, so showing the initialising expression
                     // is still worthwhile.
-                    ast::BindByRef(_) => ast::MutImmutable,
-                    ast::BindByValue(mt) => mt,
+                    ast::BindingMode::ByRef(_) => ast::MutImmutable,
+                    ast::BindingMode::ByValue(mt) => mt,
                 };
                 // collect path for either visit_local or visit_arm
                 let path = ast_util::ident_to_path(path1.span, path1.node);

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index de5595eebee71d80e3448eb163683439103a150c..89655c5c39e41ac307bc1e28d883ade2085617de 100644 (file)
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -10,7 +10,6 @@
 
 // The Rust abstract syntax tree.
 
-pub use self::BindingMode::*;
 pub use self::BinOp_::*;
 pub use self::BlockCheckMode::*;
 pub use self::CaptureClause::*;
@@ -575,8 +574,8 @@ pub struct FieldPat {
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
 pub enum BindingMode {
-    BindByRef(Mutability),
-    BindByValue(Mutability),
+    ByRef(Mutability),
+    ByValue(Mutability),
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
@@ -1655,7 +1654,7 @@ pub fn new_self(span: Span, mutability: Mutability, self_ident: Ident) -> Arg {
             }),
             pat: P(Pat {
                 id: DUMMY_NODE_ID,
-                node: PatIdent(BindByValue(mutability), path, None),
+                node: PatIdent(BindingMode::ByValue(mutability), path, None),
                 span: span
             }),
             id: DUMMY_NODE_ID

diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 3d3d53477494d2baf584568289e8fa751c8510ec..a81094d0524f899117dcd9901ab19f10982f8e81 100644 (file)
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -69,7 +69,7 @@ pub fn path_to_ident(path: &Path) -> Option<Ident> {
 pub fn ident_to_pat(id: NodeId, s: Span, i: Ident) -> P<Pat> {
     P(Pat {
         id: id,
-        node: PatIdent(BindByValue(MutImmutable), codemap::Spanned{span:s, node:i}, None),
+        node: PatIdent(BindingMode::ByValue(MutImmutable), codemap::Spanned{span:s, node:i}, None),
         span: s
     })
 }

diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index cdc9cb024530d8b578f6ca483fd897913fae49fc..bbb80ff13c75612fe6832cf170a262bf7293628f 100644 (file)
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -514,7 +514,7 @@ fn stmt_expr(&self, expr: P<ast::Expr>) -> P<ast::Stmt> {
     fn stmt_let(&self, sp: Span, mutbl: bool, ident: ast::Ident,
                 ex: P<ast::Expr>) -> P<ast::Stmt> {
         let pat = if mutbl {
-            self.pat_ident_binding_mode(sp, ident, ast::BindByValue(ast::MutMutable))
+            self.pat_ident_binding_mode(sp, ident, ast::BindingMode::ByValue(ast::MutMutable))
         } else {
             self.pat_ident(sp, ident)
         };
@@ -538,7 +538,7 @@ fn stmt_let_typed(&self,
                       ex: P<ast::Expr>)
                       -> P<ast::Stmt> {
         let pat = if mutbl {
-            self.pat_ident_binding_mode(sp, ident, ast::BindByValue(ast::MutMutable))
+            self.pat_ident_binding_mode(sp, ident, ast::BindingMode::ByValue(ast::MutMutable))
         } else {
             self.pat_ident(sp, ident)
         };
@@ -809,7 +809,7 @@ fn pat_lit(&self, span: Span, expr: P<ast::Expr>) -> P<ast::Pat> {
         self.pat(span, ast::PatLit(expr))
     }
     fn pat_ident(&self, span: Span, ident: ast::Ident) -> P<ast::Pat> {
-        self.pat_ident_binding_mode(span, ident, ast::BindByValue(ast::MutImmutable))
+        self.pat_ident_binding_mode(span, ident, ast::BindingMode::ByValue(ast::MutImmutable))
     }
 
     fn pat_ident_binding_mode(&self,

diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index e9c8173a4d9802e4bc6b0f5d7a36f0e6a06aa8e9..176dd1ea2032bb84d53a003f5ff8ca9c18a810dc 100644 (file)
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -890,7 +890,7 @@ fn parser_done(p: Parser){
         assert!(panictry!(parser.parse_pat())
                 == P(ast::Pat{
                 id: ast::DUMMY_NODE_ID,
-                node: ast::PatIdent(ast::BindByValue(ast::MutImmutable),
+                node: ast::PatIdent(ast::BindingMode::ByValue(ast::MutImmutable),
                                     Spanned{ span:sp(0, 1),
                                              node: str_to_ident("b")
                     },
@@ -926,7 +926,7 @@ fn parser_done(p: Parser){
                                     pat: P(ast::Pat {
                                         id: ast::DUMMY_NODE_ID,
                                         node: ast::PatIdent(
-                                            ast::BindByValue(ast::MutImmutable),
+                                            ast::BindingMode::ByValue(ast::MutImmutable),
                                                 Spanned{
                                                     span: sp(6,7),
                                                     node: str_to_ident("b")},

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 712f4e3801275258e570fa7183db60e3f9b9b7b2..f658e831d7b1ca08dd3cc40c28e0d358d0c971d4 100644 (file)
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -14,7 +14,7 @@
 use ast::BareFnTy;
 use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
 use ast::{Public, Unsafety};
-use ast::{Mod, BiAdd, Arg, Arm, Attribute, BindByRef, BindByValue};
+use ast::{Mod, BiAdd, Arg, Arm, Attribute, BindingMode};
 use ast::{BiBitAnd, BiBitOr, BiBitXor, BiRem, BiLt, Block};
 use ast::{BlockCheckMode, CaptureByRef, CaptureByValue, CaptureClause};
 use ast::{Constness, ConstTraitItem, Crate, CrateConfig};
@@ -3274,10 +3274,10 @@ fn parse_pat_fields(&mut self) -> PResult<(Vec<codemap::Spanned<ast::FieldPat>>
                 hi = self.last_span.hi;
 
                 let bind_type = match (is_ref, is_mut) {
-                    (true, true) => BindByRef(MutMutable),
-                    (true, false) => BindByRef(MutImmutable),
-                    (false, true) => BindByValue(MutMutable),
-                    (false, false) => BindByValue(MutImmutable),
+                    (true, true) => BindingMode::ByRef(MutMutable),
+                    (true, false) => BindingMode::ByRef(MutImmutable),
+                    (false, true) => BindingMode::ByValue(MutMutable),
+                    (false, false) => BindingMode::ByValue(MutImmutable),
                 };
                 let fieldpath = codemap::Spanned{span:self.last_span, node:fieldname};
                 let fieldpat = P(ast::Pat{
@@ -3372,11 +3372,11 @@ pub fn parse_pat(&mut self) -> PResult<P<Pat>> {
             // At this point, token != _, &, &&, (, [
             if try!(self.eat_keyword(keywords::Mut)) {
                 // Parse mut ident @ pat
-                pat = try!(self.parse_pat_ident(BindByValue(MutMutable)));
+                pat = try!(self.parse_pat_ident(BindingMode::ByValue(MutMutable)));
             } else if try!(self.eat_keyword(keywords::Ref)) {
                 // Parse ref ident @ pat / ref mut ident @ pat
                 let mutbl = try!(self.parse_mutability());
-                pat = try!(self.parse_pat_ident(BindByRef(mutbl)));
+                pat = try!(self.parse_pat_ident(BindingMode::ByRef(mutbl)));
             } else if try!(self.eat_keyword(keywords::Box)) {
                 // Parse box pat
                 let subpat = try!(self.parse_pat());
@@ -3405,7 +3405,7 @@ pub fn parse_pat(&mut self) -> PResult<P<Pat>> {
                         // Parse ident @ pat
                         // This can give false positives and parse nullary enums,
                         // they are dealt with later in resolve
-                        pat = try!(self.parse_pat_ident(BindByValue(MutImmutable)));
+                        pat = try!(self.parse_pat_ident(BindingMode::ByValue(MutImmutable)));
                     }
                 } else {
                     let (qself, path) = if try!(self.eat_lt()) {

diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 4e2289cb7f401324d83fb01e62204690a080f2ff..ded0bea59b3b14d116cd9f7a174d8d518c20c732 100644 (file)
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -2467,12 +2467,12 @@ pub fn print_pat(&mut self, pat: &ast::Pat) -> io::Result<()> {
             ast::PatWild => try!(word(&mut self.s, "_")),
             ast::PatIdent(binding_mode, ref path1, ref sub) => {
                 match binding_mode {
-                    ast::BindByRef(mutbl) => {
+                    ast::BindingMode::ByRef(mutbl) => {
                         try!(self.word_nbsp("ref"));
                         try!(self.print_mutability(mutbl));
                     }
-                    ast::BindByValue(ast::MutImmutable) => {}
-                    ast::BindByValue(ast::MutMutable) => {
+                    ast::BindingMode::ByValue(ast::MutImmutable) => {}
+                    ast::BindingMode::ByValue(ast::MutMutable) => {
                         try!(self.word_nbsp("mut"));
                     }
                 }
@@ -2678,7 +2678,7 @@ pub fn print_fn_args(&mut self, decl: &ast::FnDecl,
             let m = match *explicit_self {
                 ast::SelfStatic => ast::MutImmutable,
                 _ => match decl.inputs[0].pat.node {
-                    ast::PatIdent(ast::BindByValue(m), _, _) => m,
+                    ast::PatIdent(ast::BindingMode::ByValue(m), _, _) => m,
                     _ => ast::MutImmutable
                 }
             };

diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
index 5977144dae708b402011020338cb0b91b9691209..f7bda306fbc0f3dd740700c91e76893ba0449fcf 100644 (file)
--- a/src/libsyntax_ext/deriving/generic/mod.rs
+++ b/src/libsyntax_ext/deriving/generic/mod.rs
@@ -1471,7 +1471,7 @@ fn create_subpatterns(&self,
                           -> Vec<P<ast::Pat>> {
         field_paths.iter().map(|path| {
             cx.pat(path.span,
-                        ast::PatIdent(ast::BindByRef(mutbl), (*path).clone(), None))
+                        ast::PatIdent(ast::BindingMode::ByRef(mutbl), (*path).clone(), None))
         }).collect()
     }