[breaking-change] don't glob export ast::Mutablity variants
This commit is contained in:
parent
14e09ad468
commit
73fa9b2da2
|
@ -105,8 +105,8 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::TypeAndMut<'tcx> {
|
|||
} else {
|
||||
let mutbl = a.mutbl;
|
||||
let variance = match mutbl {
|
||||
ast::MutImmutable => ty::Covariant,
|
||||
ast::MutMutable => ty::Invariant,
|
||||
ast::Mutability::MutImmutable => ty::Covariant,
|
||||
ast::Mutability::MutMutable => ty::Invariant,
|
||||
};
|
||||
let ty = try!(relation.relate_with_variance(variance, &a.ty, &b.ty));
|
||||
Ok(ty::TypeAndMut {ty: ty, mutbl: mutbl})
|
||||
|
|
|
@ -427,8 +427,8 @@ pub fn lower_explicit_self_underscore(lctx: &LoweringContext,
|
|||
|
||||
pub fn lower_mutability(_lctx: &LoweringContext, m: Mutability) -> hir::Mutability {
|
||||
match m {
|
||||
MutMutable => hir::MutMutable,
|
||||
MutImmutable => hir::MutImmutable,
|
||||
Mutability::Mutable => hir::MutMutable,
|
||||
Mutability::Immutable => hir::MutImmutable,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -105,7 +105,7 @@ impl<'a, 'v> Visitor<'v> for CheckConstFn<'a> {
|
|||
for arg in &fd.inputs {
|
||||
match arg.pat.node {
|
||||
ast::PatWild => {}
|
||||
ast::PatIdent(ast::BindingMode::ByValue(ast::MutImmutable), _, None) => {}
|
||||
ast::PatIdent(ast::BindingMode::ByValue(ast::Mutability::Immutable), _, None) => {}
|
||||
_ => {
|
||||
span_err!(self.sess, arg.pat.span, E0022,
|
||||
"arguments of constant functions can only \
|
||||
|
|
|
@ -807,7 +807,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
|
|||
self.visit_pat(&p);
|
||||
|
||||
for &(id, ref p, immut, _) in &collector.collected_paths {
|
||||
let value = if immut == ast::MutImmutable {
|
||||
let value = if immut == ast::Mutability::Immutable {
|
||||
value.to_string()
|
||||
} else {
|
||||
"<mutable>".to_string()
|
||||
|
@ -1200,7 +1200,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
|
|||
let def = def_map.get(&id).unwrap().full_def();
|
||||
match def {
|
||||
Def::Local(_, id) => {
|
||||
let value = if immut == ast::MutImmutable {
|
||||
let value = if immut == ast::Mutability::Immutable {
|
||||
self.span.snippet(p.span).to_string()
|
||||
} else {
|
||||
"<mutable>".to_string()
|
||||
|
|
|
@ -248,8 +248,10 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
|
|||
|
||||
// If the variable is immutable, save the initialising expression.
|
||||
let (value, keyword) = match mt {
|
||||
ast::MutMutable => (String::from("<mutable>"), keywords::Mut),
|
||||
ast::MutImmutable => (self.span_utils.snippet(expr.span), keywords::Static),
|
||||
ast::Mutability::Mutable => (String::from("<mutable>"), keywords::Mut),
|
||||
ast::Mutability::Immutable => {
|
||||
(self.span_utils.snippet(expr.span), keywords::Static)
|
||||
},
|
||||
};
|
||||
|
||||
let sub_span = self.span_utils.sub_span_after_keyword(item.span, keyword);
|
||||
|
@ -758,12 +760,12 @@ impl<'v> Visitor<'v> for PathCollector {
|
|||
match p.node {
|
||||
ast::PatStruct(ref path, _, _) => {
|
||||
self.collected_paths.push((p.id, path.clone(),
|
||||
ast::MutMutable, recorder::TypeRef));
|
||||
ast::Mutability::Mutable, recorder::TypeRef));
|
||||
}
|
||||
ast::PatEnum(ref path, _) |
|
||||
ast::PatQPath(_, ref path) => {
|
||||
self.collected_paths.push((p.id, path.clone(),
|
||||
ast::MutMutable, recorder::VarRef));
|
||||
ast::Mutability::Mutable, recorder::VarRef));
|
||||
}
|
||||
ast::PatIdent(bm, ref path1, _) => {
|
||||
debug!("PathCollector, visit ident in pat {}: {:?} {:?}",
|
||||
|
@ -774,7 +776,7 @@ 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::BindingMode::ByRef(_) => ast::MutImmutable,
|
||||
ast::BindingMode::ByRef(_) => ast::Mutability::Immutable,
|
||||
ast::BindingMode::ByValue(mt) => mt,
|
||||
};
|
||||
// collect path for either visit_local or visit_arm
|
||||
|
|
|
@ -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)]
|
||||
|
|
|
@ -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
|
||||
})
|
||||
}
|
||||
|
|
|
@ -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(
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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")},
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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(()),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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| {
|
||||
|
|
|
@ -27,7 +27,7 @@ pub fn expand_deriving_debug(cx: &mut ExtCtxt,
|
|||
{
|
||||
// &mut ::std::fmt::Formatter
|
||||
let fmtr = Ptr(Box::new(Literal(path_std!(cx, core::fmt::Formatter))),
|
||||
Borrowed(None, ast::MutMutable));
|
||||
Borrowed(None, ast::Mutability::Mutable));
|
||||
|
||||
let trait_def = TraitDef {
|
||||
span: span,
|
||||
|
|
|
@ -14,7 +14,7 @@ use deriving::generic::*;
|
|||
use deriving::generic::ty::*;
|
||||
|
||||
use syntax::ast;
|
||||
use syntax::ast::{MetaItem, Expr, MutMutable};
|
||||
use syntax::ast::{MetaItem, Expr, Mutability};
|
||||
use syntax::codemap::Span;
|
||||
use syntax::ext::base::{ExtCtxt, Annotatable};
|
||||
use syntax::ext::build::AstBuilder;
|
||||
|
@ -72,7 +72,7 @@ fn expand_deriving_decodable_imp(cx: &mut ExtCtxt,
|
|||
},
|
||||
explicit_self: None,
|
||||
args: vec!(Ptr(Box::new(Literal(Path::new_local("__D"))),
|
||||
Borrowed(None, MutMutable))),
|
||||
Borrowed(None, Mutability::Mutable))),
|
||||
ret_ty: Literal(Path::new_(
|
||||
pathvec_std!(cx, core::result::Result),
|
||||
None,
|
||||
|
|
|
@ -91,7 +91,7 @@
|
|||
use deriving::generic::*;
|
||||
use deriving::generic::ty::*;
|
||||
|
||||
use syntax::ast::{MetaItem, Expr, ExprKind, MutMutable};
|
||||
use syntax::ast::{MetaItem, Expr, ExprKind, Mutability};
|
||||
use syntax::codemap::Span;
|
||||
use syntax::ext::base::{ExtCtxt,Annotatable};
|
||||
use syntax::ext::build::AstBuilder;
|
||||
|
@ -148,7 +148,7 @@ fn expand_deriving_encodable_imp(cx: &mut ExtCtxt,
|
|||
},
|
||||
explicit_self: borrowed_explicit_self(),
|
||||
args: vec!(Ptr(Box::new(Literal(Path::new_local("__S"))),
|
||||
Borrowed(None, MutMutable))),
|
||||
Borrowed(None, Mutability::Mutable))),
|
||||
ret_ty: Literal(Path::new_(
|
||||
pathvec_std!(cx, core::result::Result),
|
||||
None,
|
||||
|
|
|
@ -864,7 +864,9 @@ impl<'a> MethodDef<'a> {
|
|||
let self_arg = match explicit_self.node {
|
||||
ast::SelfKind::Static => None,
|
||||
// creating fresh self id
|
||||
_ => Some(ast::Arg::new_self(trait_.span, ast::MutImmutable, special_idents::self_))
|
||||
_ => Some(ast::Arg::new_self(trait_.span,
|
||||
ast::Mutability::Immutable,
|
||||
special_idents::self_))
|
||||
};
|
||||
let args = {
|
||||
let args = arg_types.into_iter().map(|(name, ty)| {
|
||||
|
@ -942,7 +944,7 @@ impl<'a> MethodDef<'a> {
|
|||
struct_def,
|
||||
&format!("__self_{}",
|
||||
i),
|
||||
ast::MutImmutable);
|
||||
ast::Mutability::Immutable);
|
||||
patterns.push(pat);
|
||||
raw_fields.push(ident_expr);
|
||||
}
|
||||
|
@ -1135,11 +1137,12 @@ impl<'a> MethodDef<'a> {
|
|||
let mut match_arms: Vec<ast::Arm> = variants.iter().enumerate()
|
||||
.map(|(index, variant)| {
|
||||
let mk_self_pat = |cx: &mut ExtCtxt, self_arg_name: &str| {
|
||||
let (p, idents) = trait_.create_enum_variant_pattern(cx, type_ident,
|
||||
&**variant,
|
||||
self_arg_name,
|
||||
ast::MutImmutable);
|
||||
(cx.pat(sp, ast::PatRegion(p, ast::MutImmutable)), idents)
|
||||
let (p, idents) = trait_.create_enum_variant_pattern(
|
||||
cx, type_ident,
|
||||
&**variant,
|
||||
self_arg_name,
|
||||
ast::Mutability::Immutable);
|
||||
(cx.pat(sp, ast::PatRegion(p, ast::Mutability::Immutable)), idents)
|
||||
};
|
||||
|
||||
// A single arm has form (&VariantK, &VariantK, ...) => BodyK
|
||||
|
|
|
@ -98,7 +98,7 @@ pub enum Ty<'a> {
|
|||
}
|
||||
|
||||
pub fn borrowed_ptrty<'r>() -> PtrTy<'r> {
|
||||
Borrowed(None, ast::MutImmutable)
|
||||
Borrowed(None, ast::Mutability::Immutable)
|
||||
}
|
||||
pub fn borrowed<'r>(ty: Box<Ty<'r>>) -> Ty<'r> {
|
||||
Ptr(ty, borrowed_ptrty())
|
||||
|
|
|
@ -11,7 +11,7 @@
|
|||
use deriving::generic::*;
|
||||
use deriving::generic::ty::*;
|
||||
|
||||
use syntax::ast::{MetaItem, Expr, MutMutable};
|
||||
use syntax::ast::{MetaItem, Expr, Mutability};
|
||||
use syntax::codemap::Span;
|
||||
use syntax::ext::base::{ExtCtxt, Annotatable};
|
||||
use syntax::ext::build::AstBuilder;
|
||||
|
@ -43,7 +43,7 @@ pub fn expand_deriving_hash(cx: &mut ExtCtxt,
|
|||
vec![path_std!(cx, core::hash::Hasher)])],
|
||||
},
|
||||
explicit_self: borrowed_explicit_self(),
|
||||
args: vec!(Ptr(Box::new(Literal(arg)), Borrowed(None, MutMutable))),
|
||||
args: vec!(Ptr(Box::new(Literal(arg)), Borrowed(None, Mutability::Mutable))),
|
||||
ret_ty: nil_ty(),
|
||||
attributes: vec![],
|
||||
is_unsafe: false,
|
||||
|
|
|
@ -42,7 +42,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT
|
|||
Some(cx.lifetime(sp,
|
||||
cx.ident_of(
|
||||
"'static").name)),
|
||||
ast::MutImmutable)),
|
||||
ast::Mutability::Immutable)),
|
||||
Vec::new()))
|
||||
}
|
||||
Ok(s) => {
|
||||
|
|
|
@ -450,10 +450,10 @@ impl<'a, 'b> Context<'a, 'b> {
|
|||
let ty = ecx.ty_rptr(sp,
|
||||
ecx.ty(sp, ast::TyKind::Vec(piece_ty)),
|
||||
Some(ecx.lifetime(sp, special_idents::static_lifetime.name)),
|
||||
ast::MutImmutable);
|
||||
ast::Mutability::Immutable);
|
||||
let slice = ecx.expr_vec_slice(sp, pieces);
|
||||
// static instead of const to speed up codegen by not requiring this to be inlined
|
||||
let st = ast::ItemKind::Static(ty, ast::MutImmutable, slice);
|
||||
let st = ast::ItemKind::Static(ty, ast::Mutability::Immutable, slice);
|
||||
|
||||
let name = ecx.ident_of(name);
|
||||
let item = ecx.item(sp, name, vec![], st);
|
||||
|
@ -480,7 +480,7 @@ impl<'a, 'b> Context<'a, 'b> {
|
|||
self.fmtsp,
|
||||
self.ecx.ty_ident(self.fmtsp, self.ecx.ident_of("str")),
|
||||
Some(static_lifetime),
|
||||
ast::MutImmutable);
|
||||
ast::Mutability::Immutable);
|
||||
let pieces = Context::static_array(self.ecx,
|
||||
"__STATIC_FMTSTR",
|
||||
piece_ty,
|
||||
|
|
Loading…
Reference in New Issue