mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #30460 - Ms2ger:BindingMode, r=alexcrichton

Browse Source
This commit is contained in:
bors 2015-12-21 19:10:51 +00:00
commit 709d00a231
9 changed files with 26 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/librustc_front/lowering.rs
View File

@ -1571,8 +1571,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)),
}
}

4
src/librustc_trans/save/mod.rs
View File

@ -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);

7
src/libsyntax/ast.rs
View File

@ -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::*;
@ -574,8 +573,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

2
src/libsyntax/ast_util.rs
View File

@ -68,7 +68,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
})
}

6
src/libsyntax/ext/build.rs
View File

@ -513,7 +513,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
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)
};
@ -537,7 +537,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
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)
};
@ -808,7 +808,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
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,

4
src/libsyntax/parse/mod.rs
View File

@ -892,7 +892,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")
},
@ -928,7 +928,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")},

16
src/libsyntax/parse/parser.rs
View File

@ -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};
@ -3278,10 +3278,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{
@ -3376,11 +3376,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());
@ -3409,7 +3409,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()) {

8
src/libsyntax/print/pprust.rs
View File

@ -2471,12 +2471,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"));
}
}
@ -2682,7 +2682,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
}
};

2
src/libsyntax_ext/deriving/generic/mod.rs
View File

@ -1470,7 +1470,7 @@ impl<'a> TraitDef<'a> {
-> 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()
}