From 143b9d80d06c314b8cdf5c35ea9b6661006ee6c6 Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 18 Dec 2015 14:23:01 +0100 Subject: [PATCH] Stop re-exporting the ast::BindingMode variants. --- src/librustc_front/lowering.rs | 4 ++-- src/librustc_trans/save/mod.rs | 4 ++-- src/libsyntax/ast.rs | 7 +++---- src/libsyntax/ast_util.rs | 2 +- src/libsyntax/ext/build.rs | 6 +++--- src/libsyntax/parse/mod.rs | 4 ++-- src/libsyntax/parse/parser.rs | 16 ++++++++-------- src/libsyntax/print/pprust.rs | 8 ++++---- src/libsyntax_ext/deriving/generic/mod.rs | 2 +- 9 files changed, 26 insertions(+), 27 deletions(-) diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index c0b10fb89124a..2e66aa56eaf73 100644 --- 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 cc5322d7f9f46..501ab566f1c5a 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -697,8 +697,8 @@ impl<'v> Visitor<'v> for PathCollector { // 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 de5595eebee71..89655c5c39e41 100644 --- 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 @@ impl 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 3d3d53477494d..a81094d0524f8 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -69,7 +69,7 @@ pub fn path_to_ident(path: &Path) -> Option { pub fn ident_to_pat(id: NodeId, s: Span, i: Ident) -> P { 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 cdc9cb024530d..bbb80ff13c756 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -514,7 +514,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { fn stmt_let(&self, sp: Span, mutbl: bool, ident: ast::Ident, ex: P) -> P { 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 @@ impl<'a> AstBuilder for ExtCtxt<'a> { ex: P) -> P { 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 @@ impl<'a> AstBuilder for ExtCtxt<'a> { self.pat(span, ast::PatLit(expr)) } fn pat_ident(&self, span: Span, ident: ast::Ident) -> P { - 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 e9c8173a4d980..176dd1ea2032b 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -890,7 +890,7 @@ mod tests { 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 @@ mod tests { 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 712f4e3801275..f658e831d7b1c 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -14,7 +14,7 @@ use abi; 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 @@ impl<'a> Parser<'a> { 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 @@ impl<'a> Parser<'a> { // 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 @@ impl<'a> Parser<'a> { // 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 4e2289cb7f401..ded0bea59b3b1 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -2467,12 +2467,12 @@ impl<'a> State<'a> { 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 @@ impl<'a> State<'a> { 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 5977144dae708..f7bda306fbc0f 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -1471,7 +1471,7 @@ impl<'a> TraitDef<'a> { -> Vec> { 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() }