---

yaml
---
r: 137595
b: refs/heads/master
c: 90d03d7
h: refs/heads/master
i:
  137593: 88ab308
  137591: ad4fe56
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a89ad587101b4603c8334f344d303ae6eaa99827
+refs/heads/master: 90d03d792669fed99b659d1efbe835d4b9b8873c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: cd53dac86b43e0b46f06ab265b71526242a2fc5e

trunk/src/librustc/lint/builtin.rs

@@ -978,7 +978,8 @@ impl LintPass for NonUppercaseStatics {
     fn check_item(&mut self, cx: &Context, it: &ast::Item) {
         match it.node {
             // only check static constants
-            ast::ItemStatic(_, ast::MutImmutable, _) => {
+            ast::ItemStatic(_, ast::MutImmutable, _) |
+            ast::ItemConst(..) => {
                 let s = token::get_ident(it.ident);
                 // check for lowercase letters rather than non-uppercase
                 // ones (some scripts don't have a concept of
@@ -998,7 +999,7 @@ impl LintPass for NonUppercaseStatics {
     fn check_pat(&mut self, cx: &Context, p: &ast::Pat) {
         // Lint for constants that look like binding identifiers (#7526)
         match (&p.node, cx.tcx.def_map.borrow().find(&p.id)) {
-            (&ast::PatIdent(_, ref path1, _), Some(&def::DefStatic(_, false))) => {
+            (&ast::PatIdent(_, ref path1, _), Some(&def::DefConst(..))) => {
                 let s = token::get_ident(path1.node);
                 if s.get().chars().any(|c| c.is_lowercase()) {
                     cx.span_lint(NON_UPPERCASE_STATICS, path1.span,

trunk/src/librustc/metadata/decoder.rs

@@ -126,12 +126,14 @@ enum Family {
     Trait,                 // I
     Struct,                // S
     PublicField,           // g
-    InheritedField         // N
+    InheritedField,        // N
+    Constant,              // C
 }
 
 fn item_family(item: rbml::Doc) -> Family {
     let fam = reader::get_doc(item, tag_items_data_item_family);
     match reader::doc_as_u8(fam) as char {
+      'C' => Constant,
       'c' => ImmStatic,
       'b' => MutStatic,
       'f' => Fn,
@@ -303,6 +305,7 @@ fn item_to_def_like(item: rbml::Doc, did: ast::DefId, cnum: ast::CrateNum)
     -> DefLike {
     let fam = item_family(item);
     match fam {
+        Constant  => DlDef(def::DefConst(did)),
         ImmStatic => DlDef(def::DefStatic(did, false)),
         MutStatic => DlDef(def::DefStatic(did, true)),
         Struct    => DlDef(def::DefStruct(did)),

trunk/src/librustc/metadata/encoder.rs

@@ -69,7 +69,6 @@ pub struct EncodeParams<'a, 'tcx: 'a> {
     pub tcx: &'a ty::ctxt<'tcx>,
     pub reexports2: &'a middle::resolve::ExportMap2,
     pub item_symbols: &'a RefCell<NodeMap<String>>,
-    pub non_inlineable_statics: &'a RefCell<NodeSet>,
     pub link_meta: &'a LinkMeta,
     pub cstore: &'a cstore::CStore,
     pub encode_inlined_item: EncodeInlinedItem<'a>,
@@ -81,7 +80,6 @@ pub struct EncodeContext<'a, 'tcx: 'a> {
     pub tcx: &'a ty::ctxt<'tcx>,
     pub reexports2: &'a middle::resolve::ExportMap2,
     pub item_symbols: &'a RefCell<NodeMap<String>>,
-    pub non_inlineable_statics: &'a RefCell<NodeSet>,
     pub link_meta: &'a LinkMeta,
     pub cstore: &'a cstore::CStore,
     pub encode_inlined_item: RefCell<EncodeInlinedItem<'a>>,
@@ -1069,12 +1067,20 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_symbol(ecx, rbml_w, item.id);
         encode_name(rbml_w, item.ident.name);
         encode_path(rbml_w, path);
-
-        let inlineable = !ecx.non_inlineable_statics.borrow().contains(&item.id);
-
-        if inlineable {
-            encode_inlined_item(ecx, rbml_w, IIItemRef(item));
-        }
+        encode_visibility(rbml_w, vis);
+        encode_stability(rbml_w, stab);
+        encode_attributes(rbml_w, item.attrs.as_slice());
+        rbml_w.end_tag();
+      }
+      ItemConst(_, _) => {
+        add_to_index(item, rbml_w, index);
+        rbml_w.start_tag(tag_items_data_item);
+        encode_def_id(rbml_w, def_id);
+        encode_family(rbml_w, 'C');
+        encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id));
+        encode_name(rbml_w, item.ident.name);
+        encode_path(rbml_w, path);
+        encode_inlined_item(ecx, rbml_w, IIItemRef(item));
         encode_visibility(rbml_w, vis);
         encode_stability(rbml_w, stab);
         rbml_w.end_tag();
@@ -2076,7 +2082,6 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter, parms: EncodeParams, krate:
         cstore,
         encode_inlined_item,
         link_meta,
-        non_inlineable_statics,
         reachable,
         ..
     } = parms;
@@ -2085,7 +2090,6 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter, parms: EncodeParams, krate:
         tcx: tcx,
         reexports2: reexports2,
         item_symbols: item_symbols,
-        non_inlineable_statics: non_inlineable_statics,
         link_meta: link_meta,
         cstore: cstore,
         encode_inlined_item: RefCell::new(encode_inlined_item),

trunk/src/librustc/middle/astencode.rs

@@ -460,6 +460,7 @@ impl tr for def::Def {
           def::DefMod(did) => { def::DefMod(did.tr(dcx)) }
           def::DefForeignMod(did) => { def::DefForeignMod(did.tr(dcx)) }
           def::DefStatic(did, m) => { def::DefStatic(did.tr(dcx), m) }
+          def::DefConst(did) => { def::DefConst(did.tr(dcx)) }
           def::DefLocal(nid) => { def::DefLocal(dcx.tr_id(nid)) }
           def::DefVariant(e_did, v_did, is_s) => {
             def::DefVariant(e_did.tr(dcx), v_did.tr(dcx), is_s)

trunk/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -169,15 +169,11 @@ fn check_aliasability(bccx: &BorrowckCtxt,
             // Borrow of an immutable static item:
             match safety {
                 mc::InteriorUnsafe => {
-                    // If the static item contains an Unsafe<T>, it has interior mutability.
-                    // In such cases, we cannot permit it to be borrowed, because the
-                    // static item resides in immutable memory and mutating it would
-                    // cause segfaults.
-                    bccx.tcx.sess.span_err(borrow_span,
-                                           "borrow of immutable static items \
-                                            with unsafe interior is not \
-                                            allowed");
-                    Err(())
+                    // If the static item contains an Unsafe<T>, it has interior
+                    // mutability.  In such cases, another phase of the compiler
+                    // will ensure that the type is `Sync` and then trans will
+                    // not put it in rodata, so this is ok to allow.
+                    Ok(())
                 }
                 mc::InteriorSafe => {
                     // Immutable static can be borrowed, no problem.

trunk/src/librustc/middle/borrowck/mod.rs

@@ -106,7 +106,8 @@ fn borrowck_item(this: &mut BorrowckCtxt, item: &ast::Item) {
     // loan step is intended for things that have a data
     // flow dependent conditions.
     match item.node {
-        ast::ItemStatic(_, _, ref ex) => {
+        ast::ItemStatic(_, _, ref ex) |
+        ast::ItemConst(_, ref ex) => {
             gather_loans::gather_loans_in_static_initializer(this, &**ex);
         }
         _ => {

trunk/src/librustc/middle/check_const.rs

@@ -48,7 +48,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
     }
     fn visit_expr(&mut self, ex: &Expr) {
         if check_expr(self, ex) {
-            visit::walk_expr(v, e);
+            visit::walk_expr(self, ex);
         }
     }
 }
@@ -61,7 +61,8 @@ pub fn check_crate(tcx: &ty::ctxt) {
 
 fn check_item(v: &mut CheckCrateVisitor, it: &Item) {
     match it.node {
-        ItemStatic(_, _, ref ex) => {
+        ItemStatic(_, _, ref ex) |
+        ItemConst(_, ref ex) => {
             v.inside_const(|v| v.visit_expr(&**ex));
         }
         ItemEnum(ref enum_definition, _) => {
@@ -138,6 +139,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr) -> bool {
             }
             match v.tcx.def_map.borrow().find(&e.id) {
                 Some(&DefStatic(..)) |
+                Some(&DefConst(..)) |
                 Some(&DefFn(..)) |
                 Some(&DefVariant(_, _, _)) |
                 Some(&DefStruct(_)) => { }
@@ -190,7 +192,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr) -> bool {
                 }
             }
             match block.expr {
-                Some(ref expr) => check_expr(v, &**expr),
+                Some(ref expr) => { check_expr(v, &**expr); }
                 None => {}
             }
         }

trunk/src/librustc/middle/check_match.rs

@@ -32,7 +32,7 @@ use syntax::ptr::P;
 use syntax::visit::{mod, Visitor, FnKind};
 use util::ppaux::ty_to_string;
 
-static DUMMY_WILD_PAT: Pat = Pat {
+pub const DUMMY_WILD_PAT: Pat = Pat {
     id: DUMMY_NODE_ID,
     node: PatWild(PatWildSingle),
     span: DUMMY_SP
@@ -299,9 +299,10 @@ fn raw_pat<'a>(p: &'a Pat) -> &'a Pat {
 fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix) {
     match is_useful(cx, matrix, &[&DUMMY_WILD_PAT], ConstructWitness) {
         UsefulWithWitness(pats) => {
+            let dummy = DUMMY_WILD_PAT.clone();
             let witness = match pats.as_slice() {
                 [ref witness] => &**witness,
-                [] => &DUMMY_WILD_PAT,
+                [] => &dummy,
                 _ => unreachable!()
             };
             span_err!(cx.tcx.sess, sp, E0004,
@@ -349,7 +350,7 @@ impl<'a, 'tcx> Folder for StaticInliner<'a, 'tcx> {
             PatIdent(..) | PatEnum(..) => {
                 let def = self.tcx.def_map.borrow().find_copy(&pat.id);
                 match def {
-                    Some(DefStatic(did, _)) => match lookup_const_by_id(self.tcx, did) {
+                    Some(DefConst(did)) => match lookup_const_by_id(self.tcx, did) {
                         Some(const_expr) => {
                             const_expr_to_pat(self.tcx, const_expr).map(|mut new_pat| {
                                 new_pat.span = pat.span;
@@ -359,7 +360,7 @@ impl<'a, 'tcx> Folder for StaticInliner<'a, 'tcx> {
                         None => {
                             self.failed = true;
                             span_err!(self.tcx.sess, pat.span, E0158,
-                                "extern statics cannot be referenced in patterns");
+                                "statics cannot be referenced in patterns");
                             pat
                         }
                     },
@@ -555,8 +556,9 @@ fn is_useful(cx: &MatchCheckCtxt,
                             let arity = constructor_arity(cx, &c, left_ty);
                             let mut result = {
                                 let pat_slice = pats.as_slice();
+                                let dummy = DUMMY_WILD_PAT.clone();
                                 let subpats = Vec::from_fn(arity, |i| {
-                                    pat_slice.get(i).map_or(&DUMMY_WILD_PAT, |p| &**p)
+                                    pat_slice.get(i).map_or(&dummy, |p| &**p)
                                 });
                                 vec![construct_witness(cx, &c, subpats, left_ty)]
                             };
@@ -578,8 +580,9 @@ fn is_useful(cx: &MatchCheckCtxt,
                 }).collect();
                 match is_useful(cx, &matrix, v.tail(), witness) {
                     UsefulWithWitness(pats) => {
+                        let dummy = DUMMY_WILD_PAT.clone();
                         let arity = constructor_arity(cx, &constructor, left_ty);
-                        let wild_pats = Vec::from_elem(arity, &DUMMY_WILD_PAT);
+                        let wild_pats = Vec::from_elem(arity, &dummy);
                         let enum_pat = construct_witness(cx, &constructor, wild_pats, left_ty);
                         let mut new_pats = vec![enum_pat];
                         new_pats.extend(pats.into_iter());
@@ -600,10 +603,11 @@ fn is_useful_specialized(cx: &MatchCheckCtxt, &Matrix(ref m): &Matrix,
                          v: &[&Pat], ctor: Constructor, lty: ty::t,
                          witness: WitnessPreference) -> Usefulness {
     let arity = constructor_arity(cx, &ctor, lty);
+    let dummy = DUMMY_WILD_PAT.clone();
     let matrix = Matrix(m.iter().filter_map(|r| {
-        specialize(cx, r.as_slice(), &ctor, 0u, arity)
+        specialize(cx, r.as_slice(), &dummy, &ctor, 0u, arity)
     }).collect());
-    match specialize(cx, v, &ctor, 0u, arity) {
+    match specialize(cx, v, &dummy, &ctor, 0u, arity) {
         Some(v) => is_useful(cx, &matrix, v.as_slice(), witness),
         None => NotUseful
     }
@@ -624,23 +628,26 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
     match pat.node {
         PatIdent(..) =>
             match cx.tcx.def_map.borrow().find(&pat.id) {
-                Some(&DefStatic(..)) =>
-                    cx.tcx.sess.span_bug(pat.span, "static pattern should've been rewritten"),
+                Some(&DefConst(..)) =>
+                    cx.tcx.sess.span_bug(pat.span, "const pattern should've \
+                                                    been rewritten"),
                 Some(&DefStruct(_)) => vec!(Single),
                 Some(&DefVariant(_, id, _)) => vec!(Variant(id)),
                 _ => vec!()
             },
         PatEnum(..) =>
             match cx.tcx.def_map.borrow().find(&pat.id) {
-                Some(&DefStatic(..)) =>
-                    cx.tcx.sess.span_bug(pat.span, "static pattern should've been rewritten"),
+                Some(&DefConst(..)) =>
+                    cx.tcx.sess.span_bug(pat.span, "static pattern should've \
+                                                    been rewritten"),
                 Some(&DefVariant(_, id, _)) => vec!(Variant(id)),
                 _ => vec!(Single)
             },
         PatStruct(..) =>
             match cx.tcx.def_map.borrow().find(&pat.id) {
-                Some(&DefStatic(..)) =>
-                    cx.tcx.sess.span_bug(pat.span, "static pattern should've been rewritten"),
+                Some(&DefConst(..)) =>
+                    cx.tcx.sess.span_bug(pat.span, "static pattern should've \
+                                                    been rewritten"),
                 Some(&DefVariant(_, id, _)) => vec!(Variant(id)),
                 _ => vec!(Single)
             },
@@ -722,40 +729,42 @@ fn range_covered_by_constructor(ctor: &Constructor,
 /// different patterns.
 /// Structure patterns with a partial wild pattern (Foo { a: 42, .. }) have their missing
 /// fields filled with wild patterns.
-pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
+pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], dummy: &'a Pat,
                       constructor: &Constructor, col: uint, arity: uint) -> Option<Vec<&'a Pat>> {
     let &Pat {
         id: pat_id, node: ref node, span: pat_span
     } = raw_pat(r[col]);
     let head: Option<Vec<&Pat>> = match node {
 
         &PatWild(_) =>
-            Some(Vec::from_elem(arity, &DUMMY_WILD_PAT)),
+            Some(Vec::from_elem(arity, dummy)),
 
         &PatIdent(_, _, _) => {
             let opt_def = cx.tcx.def_map.borrow().find_copy(&pat_id);
             match opt_def {
-                Some(DefStatic(..)) =>
-                    cx.tcx.sess.span_bug(pat_span, "static pattern should've been rewritten"),
+                Some(DefConst(..)) =>
+                    cx.tcx.sess.span_bug(pat_span, "const pattern should've \
+                                                    been rewritten"),
                 Some(DefVariant(_, id, _)) => if *constructor == Variant(id) {
                     Some(vec!())
                 } else {
                     None
                 },
-                _ => Some(Vec::from_elem(arity, &DUMMY_WILD_PAT))
+                _ => Some(Vec::from_elem(arity, dummy))
             }
         }
 
         &PatEnum(_, ref args) => {
             let def = cx.tcx.def_map.borrow().get_copy(&pat_id);
             match def {
-                DefStatic(..) =>
-                    cx.tcx.sess.span_bug(pat_span, "static pattern should've been rewritten"),
+                DefConst(..) =>
+                    cx.tcx.sess.span_bug(pat_span, "const pattern should've \
+                                                    been rewritten"),
                 DefVariant(_, id, _) if *constructor != Variant(id) => None,
                 DefVariant(..) | DefStruct(..) => {
                     Some(match args {
                         &Some(ref args) => args.iter().map(|p| &**p).collect(),
-                        &None => Vec::from_elem(arity, &DUMMY_WILD_PAT)
+                        &None => Vec::from_elem(arity, dummy)
                     })
                 }
                 _ => None
@@ -766,8 +775,9 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
             // Is this a struct or an enum variant?
             let def = cx.tcx.def_map.borrow().get_copy(&pat_id);
             let class_id = match def {
-                DefStatic(..) =>
-                    cx.tcx.sess.span_bug(pat_span, "static pattern should've been rewritten"),
+                DefConst(..) =>
+                    cx.tcx.sess.span_bug(pat_span, "const pattern should've \
+                                                    been rewritten"),
                 DefVariant(_, variant_id, _) => if *constructor == Variant(variant_id) {
                     Some(variant_id)
                 } else {
@@ -790,7 +800,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
                 let args = struct_fields.iter().map(|sf| {
                     match pattern_fields.iter().find(|f| f.ident.name == sf.name) {
                         Some(ref f) => &*f.pat,
-                        _ => &DUMMY_WILD_PAT
+                        _ => dummy
                     }
                 }).collect();
                 args
@@ -833,13 +843,13 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
                 // Fixed-length vectors.
                 Single => {
                     let mut pats: Vec<&Pat> = before.iter().map(|p| &**p).collect();
-                    pats.grow_fn(arity - before.len() - after.len(), |_| &DUMMY_WILD_PAT);
+                    pats.grow_fn(arity - before.len() - after.len(), |_| dummy);
                     pats.extend(after.iter().map(|p| &**p));
                     Some(pats)
                 },
                 Slice(length) if before.len() + after.len() <= length && slice.is_some() => {
                     let mut pats: Vec<&Pat> = before.iter().map(|p| &**p).collect();
-                    pats.grow_fn(arity - before.len() - after.len(), |_| &DUMMY_WILD_PAT);
+                    pats.grow_fn(arity - before.len() - after.len(), |_| dummy);
                     pats.extend(after.iter().map(|p| &**p));
                     Some(pats)
                 },