OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

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
Show Stats 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,

17
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,
&**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

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,