rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

[breaking-change] don't glob export ast::Mutablity variants

Browse Source
This commit is contained in:
Oliver 'ker' Schneider
2016-02-09 17:44:47 +01:00
committed by Oliver Schneider
parent 14e09ad468
commit 73fa9b2da2
21 changed files with 87 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/libsyntax/ast.rs
View File

@@ -10,7 +10,6 @@
// The Rust abstract syntax tree.
pub use self::Mutability::*;
pub use self::Pat_::*;
pub use self::PathListItem_::*;
pub use self::StrStyle::*;
@@ -602,8 +601,8 @@ pub enum Pat_ {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum Mutability {
MutMutable,
MutImmutable,
Mutable,
Immutable,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]

3
src/libsyntax/ast_util.rs
View File

@@ -66,9 +66,10 @@ pub fn path_to_ident(path: &Path) -> Option<Ident> {
}
pub fn ident_to_pat(id: NodeId, s: Span, i: Ident) -> P<Pat> {
let spanned = codemap::Spanned{ span: s, node: i };
P(Pat {
id: id,
node: PatIdent(BindingMode::ByValue(MutImmutable), codemap::Spanned{span:s, node:i}, None),
node: PatIdent(BindingMode::ByValue(Mutability::Immutable), spanned, None),
span: s
})
}

2
src/libsyntax/diagnostics/plugin.rs
View File

@@ -207,7 +207,7 @@ pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt,
span,
ecx.ty_ident(span, ecx.ident_of("str")),
Some(static_),
ast::MutImmutable,
ast::Mutability::Immutable,
);
let ty = ecx.ty(

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

@@ -512,7 +512,8 @@ 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::BindingMode::ByValue(ast::MutMutable))
let binding_mode = ast::BindingMode::ByValue(ast::Mutability::Mutable);
self.pat_ident_binding_mode(sp, ident, binding_mode)
} else {
self.pat_ident(sp, ident)
};
@@ -536,7 +537,8 @@ 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::BindingMode::ByValue(ast::MutMutable))
let binding_mode = ast::BindingMode::ByValue(ast::Mutability::Mutable);
self.pat_ident_binding_mode(sp, ident, binding_mode)
} else {
self.pat_ident(sp, ident)
};
@@ -636,10 +638,10 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
self.expr(sp, ast::ExprKind::TupField(expr, id))
}
fn expr_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprKind::AddrOf(ast::MutImmutable, e))
self.expr(sp, ast::ExprKind::AddrOf(ast::Mutability::Immutable, e))
}
fn expr_mut_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
self.expr(sp, ast::ExprKind::AddrOf(ast::MutMutable, e))
self.expr(sp, ast::ExprKind::AddrOf(ast::Mutability::Mutable, e))
}
fn expr_call(&self, span: Span, expr: P<ast::Expr>, args: Vec<P<ast::Expr>>) -> P<ast::Expr> {
@@ -813,7 +815,8 @@ 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::BindingMode::ByValue(ast::MutImmutable))
let binding_mode = ast::BindingMode::ByValue(ast::Mutability::Immutable);
self.pat_ident_binding_mode(span, ident, binding_mode)
}
fn pat_ident_binding_mode(&self,

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

@@ -896,7 +896,7 @@ mod tests {
assert!(panictry!(parser.parse_pat())
== P(ast::Pat{
id: ast::DUMMY_NODE_ID,
node: ast::PatIdent(ast::BindingMode::ByValue(ast::MutImmutable),
node: ast::PatIdent(ast::BindingMode::ByValue(ast::Mutability::Immutable),
Spanned{ span:sp(0, 1),
node: str_to_ident("b")
},
@@ -932,7 +932,7 @@ mod tests {
pat: P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: ast::PatIdent(
ast::BindingMode::ByValue(ast::MutImmutable),
ast::BindingMode::ByValue(ast::Mutability::Immutable),
Spanned{
span: sp(6,7),
node: str_to_ident("b")},

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

@@ -27,7 +27,7 @@ use ast::{Ident, Inherited, ImplItem, Item, ItemKind};
use ast::{Lit, LitKind, UintTy};
use ast::Local;
use ast::MacStmtStyle;
use ast::{MutImmutable, MutMutable, Mac_};
use ast::Mac_;
use ast::{MutTy, Mutability};
use ast::NamedField;
use ast::{Pat, PatBox, PatEnum, PatIdent, PatLit, PatQPath, PatMac, PatRange};
@@ -1417,16 +1417,16 @@ impl<'a> Parser<'a> {
pub fn parse_ptr(&mut self) -> PResult<'a, MutTy> {
let mutbl = if self.eat_keyword(keywords::Mut) {
MutMutable
Mutability::Mutable
} else if self.eat_keyword(keywords::Const) {
MutImmutable
Mutability::Immutable
} else {
let span = self.last_span;
self.span_err(span,
"bare raw pointers are no longer allowed, you should \
likely use `*mut T`, but otherwise `*T` is now \
known as `*const T`");
MutImmutable
Mutability::Immutable
};
let t = try!(self.parse_ty());
Ok(MutTy { ty: t, mutbl: mutbl })
@@ -1924,9 +1924,9 @@ impl<'a> Parser<'a> {
/// Parse mutability declaration (mut/const/imm)
pub fn parse_mutability(&mut self) -> PResult<'a, Mutability> {
if self.eat_keyword(keywords::Mut) {
Ok(MutMutable)
Ok(Mutability::Mutable)
} else {
Ok(MutImmutable)
Ok(Mutability::Immutable)
}
}
@@ -3350,10 +3350,10 @@ impl<'a> Parser<'a> {
hi = self.last_span.hi;
let bind_type = match (is_ref, is_mut) {
(true, true) => BindingMode::ByRef(MutMutable),
(true, false) => BindingMode::ByRef(MutImmutable),
(false, true) => BindingMode::ByValue(MutMutable),
(false, false) => BindingMode::ByValue(MutImmutable),
(true, true) => BindingMode::ByRef(Mutability::Mutable),
(true, false) => BindingMode::ByRef(Mutability::Immutable),
(false, true) => BindingMode::ByValue(Mutability::Mutable),
(false, false) => BindingMode::ByValue(Mutability::Immutable),
};
let fieldpath = codemap::Spanned{span:self.last_span, node:fieldname};
let fieldpat = P(ast::Pat{
@@ -3448,7 +3448,7 @@ impl<'a> Parser<'a> {
// At this point, token != _, &, &&, (, [
if self.eat_keyword(keywords::Mut) {
// Parse mut ident @ pat
pat = try!(self.parse_pat_ident(BindingMode::ByValue(MutMutable)));
pat = try!(self.parse_pat_ident(BindingMode::ByValue(Mutability::Mutable)));
} else if self.eat_keyword(keywords::Ref) {
// Parse ref ident @ pat / ref mut ident @ pat
let mutbl = try!(self.parse_mutability());
@@ -3481,7 +3481,8 @@ 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(BindingMode::ByValue(MutImmutable)));
let binding_mode = BindingMode::ByValue(Mutability::Immutable);
pat = try!(self.parse_pat_ident(binding_mode));
}
} else {
let (qself, path) = if self.eat_lt() {
@@ -4408,7 +4409,7 @@ impl<'a> Parser<'a> {
if this.look_ahead(1, |t| t.is_keyword(keywords::SelfValue)) {
this.bump();
Ok(SelfKind::Region(None, MutImmutable, try!(this.expect_self_ident())))
Ok(SelfKind::Region(None, Mutability::Immutable, try!(this.expect_self_ident())))
} else if this.look_ahead(1, |t| t.is_mutability()) &&
this.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) {
this.bump();
@@ -4418,7 +4419,8 @@ impl<'a> Parser<'a> {
this.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) {
this.bump();
let lifetime = try!(this.parse_lifetime());
Ok(SelfKind::Region(Some(lifetime), MutImmutable, try!(this.expect_self_ident())))
let ident = try!(this.expect_self_ident());
Ok(SelfKind::Region(Some(lifetime), Mutability::Immutable, ident))
} else if this.look_ahead(1, |t| t.is_lifetime()) &&
this.look_ahead(2, |t| t.is_mutability()) &&
this.look_ahead(3, |t| t.is_keyword(keywords::SelfValue)) {
@@ -4439,7 +4441,7 @@ impl<'a> Parser<'a> {
let mut self_ident_lo = self.span.lo;
let mut self_ident_hi = self.span.hi;
let mut mutbl_self = MutImmutable;
let mut mutbl_self = Mutability::Immutable;
let explicit_self = match self.token {
token::BinOp(token::And) => {
let eself = try!(maybe_parse_borrowed_explicit_self(self));
@@ -4454,7 +4456,7 @@ impl<'a> Parser<'a> {
let _mutability = if self.token.is_mutability() {
try!(self.parse_mutability())
} else {
MutImmutable
Mutability::Immutable
};
if self.is_self_ident() {
let span = self.span;
@@ -5527,7 +5529,11 @@ impl<'a> Parser<'a> {
if self.eat_keyword(keywords::Static) {
// STATIC ITEM
let m = if self.eat_keyword(keywords::Mut) {MutMutable} else {MutImmutable};
let m = if self.eat_keyword(keywords::Mut) {
Mutability::Mutable
} else {
Mutability::Immutable
};
let (ident, item_, extra_attrs) = try!(self.parse_item_const(Some(m)));
let last_span = self.last_span;
let item = self.mk_item(lo,

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

@@ -417,7 +417,7 @@ pub fn lit_to_string(l: &ast::Lit) -> String {
}
pub fn explicit_self_to_string(explicit_self: &ast::SelfKind) -> String {
to_string(|s| s.print_explicit_self(explicit_self, ast::MutImmutable).map(|_| {}))
to_string(|s| s.print_explicit_self(explicit_self, ast::Mutability::Immutable).map(|_| {}))
}
pub fn variant_to_string(var: &ast::Variant) -> String {
@@ -965,8 +965,8 @@ impl<'a> State<'a> {
ast::TyKind::Ptr(ref mt) => {
try!(word(&mut self.s, "*"));
match mt.mutbl {
ast::MutMutable => try!(self.word_nbsp("mut")),
ast::MutImmutable => try!(self.word_nbsp("const")),
ast::Mutability::Mutable => try!(self.word_nbsp("mut")),
ast::Mutability::Immutable => try!(self.word_nbsp("const")),
}
try!(self.print_type(&*mt.ty));
}
@@ -1147,7 +1147,7 @@ impl<'a> State<'a> {
ast::ItemKind::Static(ref ty, m, ref expr) => {
try!(self.head(&visibility_qualified(item.vis,
"static")));
if m == ast::MutMutable {
if m == ast::Mutability::Mutable {
try!(self.word_space("mut"));
}
try!(self.print_ident(item.ident));
@@ -2464,8 +2464,8 @@ impl<'a> State<'a> {
try!(self.word_nbsp("ref"));
try!(self.print_mutability(mutbl));
}
ast::BindingMode::ByValue(ast::MutImmutable) => {}
ast::BindingMode::ByValue(ast::MutMutable) => {
ast::BindingMode::ByValue(ast::Mutability::Immutable) => {}
ast::BindingMode::ByValue(ast::Mutability::Mutable) => {
try!(self.word_nbsp("mut"));
}
}
@@ -2534,7 +2534,7 @@ impl<'a> State<'a> {
}
ast::PatRegion(ref inner, mutbl) => {
try!(word(&mut self.s, "&"));
if mutbl == ast::MutMutable {
if mutbl == ast::Mutability::Mutable {
try!(word(&mut self.s, "mut "));
}
try!(self.print_pat(&**inner));
@@ -2669,10 +2669,10 @@ impl<'a> State<'a> {
let mut first = true;
if let Some(explicit_self) = opt_explicit_self {
let m = match *explicit_self {
ast::SelfKind::Static => ast::MutImmutable,
ast::SelfKind::Static => ast::Mutability::Immutable,
_ => match decl.inputs[0].pat.node {
ast::PatIdent(ast::BindingMode::ByValue(m), _, _) => m,
_ => ast::MutImmutable
_ => ast::Mutability::Immutable
}
};
first = !try!(self.print_explicit_self(explicit_self, m));
@@ -2946,8 +2946,8 @@ impl<'a> State<'a> {
pub fn print_mutability(&mut self,
mutbl: ast::Mutability) -> io::Result<()> {
match mutbl {
ast::MutMutable => self.word_nbsp("mut"),
ast::MutImmutable => Ok(()),
ast::Mutability::Mutable => self.word_nbsp("mut"),
ast::Mutability::Immutable => Ok(()),
}
}

4
src/libsyntax/test.rs
View File

@@ -593,7 +593,7 @@ fn mk_tests(cx: &TestCtxt) -> P<ast::Item> {
let static_type = ecx.ty_rptr(sp,
ecx.ty(sp, ast::TyKind::Vec(struct_type)),
Some(static_lt),
ast::MutImmutable);
ast::Mutability::Immutable);
// static TESTS: $static_type = &[...];
ecx.item_const(sp,
ecx.ident_of("TESTS"),
@@ -613,7 +613,7 @@ fn mk_test_descs(cx: &TestCtxt) -> P<ast::Expr> {
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprKind::AddrOf(ast::MutImmutable,
node: ast::ExprKind::AddrOf(ast::Mutability::Immutable,
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprKind::Vec(cx.testfns.iter().map(|test| {