bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests 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

4
src/librustc/middle/ty/relate.rs
View file

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

4
src/librustc_front/lowering.rs
View file

@ -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,
}
}

2
src/librustc_passes/const_fn.rs
View file

@ -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 \

4
src/librustc_trans/save/dump_csv.rs
View file

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

12
src/librustc_trans/save/mod.rs
View file

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

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| {

2
src/libsyntax_ext/deriving/debug.rs
View file

@ -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,

4
src/libsyntax_ext/deriving/decodable.rs
View file

@ -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,

4
src/libsyntax_ext/deriving/encodable.rs
View file

@ -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,

13
src/libsyntax_ext/deriving/generic/mod.rs
View file

@ -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,
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)
ast::Mutability::Immutable);
(cx.pat(sp, ast::PatRegion(p, ast::Mutability::Immutable)), idents)
};
// A single arm has form (&VariantK, &VariantK, ...) => BodyK

2
src/libsyntax_ext/deriving/generic/ty.rs
View file

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

4
src/libsyntax_ext/deriving/hash.rs
View file

@ -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,

2
src/libsyntax_ext/env.rs
View file

@ -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) => {

6
src/libsyntax_ext/format.rs
View file

@ -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,