---

yaml
---
r: 212277
b: refs/heads/master
c: 1be9e6f
h: refs/heads/master
i:
  212275: f8d85a3
v: v3

Author: tamird

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1ade076f62c9e8188c4fb5c888277a1673ac82cd
+refs/heads/master: 1be9e6f055fbcd6bfcf0a1f9e9ef0e86abe54f02
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: 1864973ae17213c5a58c4dd3f9af6d1b6c7d2e05

trunk/src/liballoc/boxed.rs

@@ -81,7 +81,7 @@ use core::raw::{TraitObject};
 #[lang = "exchange_heap"]
 #[unstable(feature = "alloc",
            reason = "may be renamed; uncertain about custom allocator design")]
-pub const HEAP: () = ();
+pub static HEAP: () = ();
 
 /// A pointer type for heap allocation.
 ///

trunk/src/libcollections/bit.rs

@@ -125,8 +125,8 @@ fn match_words <'a,'b>(a: &'a BitVec, b: &'b BitVec) -> (MatchWords<'a>, MatchWo
     }
 }
 
-const TRUE: &'static bool = &true;
-const FALSE: &'static bool = &false;
+static TRUE: bool = true;
+static FALSE: bool = false;
 
 /// The bitvector type.
 ///
@@ -172,9 +172,9 @@ impl Index<usize> for BitVec {
     #[inline]
     fn index(&self, i: usize) -> &bool {
         if self.get(i).expect("index out of bounds") {
-            TRUE
+            &TRUE
         } else {
-            FALSE
+            &FALSE
         }
     }
 }

trunk/src/libcollections/vec.rs

@@ -83,7 +83,7 @@ use borrow::{Cow, IntoCow};
 use super::range::RangeArgument;
 
 // FIXME- fix places which assume the max vector allowed has memory usize::MAX.
-const MAX_MEMORY_SIZE: usize = isize::MAX as usize;
+static MAX_MEMORY_SIZE: usize = isize::MAX as usize;
 
 /// A growable list type, written `Vec<T>` but pronounced 'vector.'
 ///

trunk/src/libcore/num/flt2dec/strategy/dragon.rs

@@ -24,6 +24,7 @@ use num::flt2dec::estimator::estimate_scaling_factor;
 use num::flt2dec::bignum::Digit32 as Digit;
 use num::flt2dec::bignum::Big32x36 as Big;
 
+// FIXME(#22540) const ref to static array seems to ICE
 static POW10: [Digit; 10] = [1, 10, 100, 1000, 10000, 100000,
                              1000000, 10000000, 100000000, 1000000000];
 static TWOPOW10: [Digit; 10] = [2, 20, 200, 2000, 20000, 200000,
@@ -327,3 +328,4 @@ pub fn format_exact(d: &Decoded, buf: &mut [u8], limit: i16) -> (/*#digits*/ usi
 
     (len, k)
 }
+

trunk/src/libcore/num/flt2dec/strategy/grisu.rs

@@ -87,7 +87,7 @@ for i in xrange(-308, 333, 8):
     f = ((f << 64 >> (l-1)) + 1) >> 1; e += l - 64
     print '    (%#018x, %5d, %4d),' % (f, e, i)
 */
-
+// FIXME(#22540) const ref to static array seems to ICE
 #[doc(hidden)]
 pub static CACHED_POW10: [(u64, i16, i16); 81] = [ // (f, e, k)
     (0xe61acf033d1a45df, -1087, -308),
@@ -746,3 +746,4 @@ pub fn format_exact(d: &Decoded, buf: &mut [u8], limit: i16) -> (/*#digits*/ usi
         None => fallback(d, buf, limit),
     }
 }
+

trunk/src/liblog/directive.rs

@@ -17,7 +17,7 @@ pub struct LogDirective {
     pub level: u32,
 }
 
-pub const LOG_LEVEL_NAMES: [&'static str; 4] = ["ERROR", "WARN", "INFO",
+pub static LOG_LEVEL_NAMES: [&'static str; 4] = ["ERROR", "WARN", "INFO",
                                                "DEBUG"];
 
 /// Parse an individual log level that is either a number or a symbolic log level

trunk/src/librand/distributions/ziggurat_tables.rs

@@ -12,7 +12,7 @@
 // algorithm. Autogenerated by `ziggurat_tables.py`.
 
 pub type ZigTable = &'static [f64; 257];
-pub const ZIG_NORM_R: f64 = 3.654152885361008796;
+pub static ZIG_NORM_R: f64 = 3.654152885361008796;
 pub static ZIG_NORM_X: [f64; 257] =
     [3.910757959537090045, 3.654152885361008796, 3.449278298560964462, 3.320244733839166074,
      3.224575052047029100, 3.147889289517149969, 3.083526132001233044, 3.027837791768635434,
@@ -145,7 +145,7 @@ pub static ZIG_NORM_F: [f64; 257] =
      0.887984660763399880, 0.898095921906304051, 0.908726440060562912, 0.919991505048360247,
      0.932060075968990209, 0.945198953453078028, 0.959879091812415930, 0.977101701282731328,
      1.000000000000000000];
-pub const ZIG_EXP_R: f64 = 7.697117470131050077;
+pub static ZIG_EXP_R: f64 = 7.697117470131050077;
 pub static ZIG_EXP_X: [f64; 257] =
     [8.697117470131052741, 7.697117470131050077, 6.941033629377212577, 6.478378493832569696,
      6.144164665772472667, 5.882144315795399869, 5.666410167454033697, 5.482890627526062488,

trunk/src/librustc/diagnostics.rs

@@ -227,25 +227,6 @@ const Y: i32 = A;
 ```
 "##,
 
-E0014: r##"
-Constants can only be initialized by a constant value or, in a future
-version of Rust, a call to a const function. This error indicates the use
-of a path (like a::b, or x) denoting something other than one of these
-allowed items. Example:
-
-```
-const FOO: i32 = { let x = 0; x }; // 'x' isn't a constant nor a function!
-```
-
-To avoid it, you have to replace the non-constant value:
-
-```
-const FOO: i32 = { const X : i32 = 0; X };
-// or even:
-const FOO: i32 = { 0 }; // but brackets are useless here
-```
-"##,
-
 E0015: r##"
 The only functions that can be called in static or constant expressions are
 `const` functions. Rust currently does not support more general compile-time
@@ -950,6 +931,7 @@ static mut BAR: Option<Vec<i32>> = None;
 
 
 register_diagnostics! {
+    E0014,
     E0016,
     E0017,
     E0019,

trunk/src/librustc/lint/mod.rs

@@ -101,8 +101,9 @@ macro_rules! declare_lint {
 #[macro_export]
 macro_rules! lint_array { ($( $lint:expr ),*) => (
     {
-        static ARRAY: LintArray = &[ $( &$lint ),* ];
-        ARRAY
+        #[allow(non_upper_case_globals)]
+        static array: LintArray = &[ $( &$lint ),* ];
+        array
     }
 ) }
 

trunk/src/librustc/metadata/tydecode.rs

@@ -50,6 +50,9 @@ pub enum DefIdSource {
     // Identifies a type alias (`type X = ...`).
     TypeWithId,
 
+    // Identifies a type parameter (`fn foo<X>() { ... }`).
+    TypeParameter,
+
     // Identifies a region parameter (`fn foo<'X>() { ... }`).
     RegionParameter,
 
@@ -190,7 +193,7 @@ pub fn parse_substs_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: us
                                   tcx: &ty::ctxt<'tcx>, conv: F) -> subst::Substs<'tcx> where
     F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
 {
-    debug!("parse_substs_data{}", data_log_string(data, pos));
+    debug!("parse_substs_data {}", data_log_string(data, pos));
     let mut st = parse_state_from_data(data, crate_num, pos, tcx);
     parse_substs(&mut st, conv)
 }
@@ -539,14 +542,7 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w
                                          len: len };
 
         match tcx.rcache.borrow().get(&key).cloned() {
-          Some(tt) => {
-            // If there is a closure buried in the type some where, then we
-            // need to re-convert any def ids (see case 'k', below). That means
-            // we can't reuse the cached version.
-            if !ty::type_has_ty_closure(tt) {
-                return tt;
-            }
-          }
+          Some(tt) => return tt,
           None => {}
         }
         let mut ps = PState {

trunk/src/librustc/middle/astencode.rs

@@ -20,7 +20,7 @@ use middle::def;
 use metadata::encoder as e;
 use middle::region;
 use metadata::tydecode;
-use metadata::tydecode::{DefIdSource, NominalType, TypeWithId};
+use metadata::tydecode::{DefIdSource, NominalType, TypeWithId, TypeParameter};
 use metadata::tydecode::{RegionParameter, ClosureSource};
 use metadata::tyencode;
 use middle::cast;
@@ -346,6 +346,13 @@ impl<D:serialize::Decoder> def_id_decoder_helpers for D
 // ______________________________________________________________________
 // Encoding and decoding the AST itself
 //
+// The hard work is done by an autogenerated module astencode_gen.  To
+// regenerate astencode_gen, run src/etc/gen-astencode.  It will
+// replace astencode_gen with a dummy file and regenerate its
+// contents.  If you get compile errors, the dummy file
+// remains---resolve the errors and then rerun astencode_gen.
+// Annoying, I know, but hopefully only temporary.
+//
 // When decoding, we have to renumber the AST so that the node ids that
 // appear within are disjoint from the node ids in our existing ASTs.
 // We also have to adjust the spans: for now we just insert a dummy span,
@@ -649,6 +656,35 @@ impl<'a, 'tcx> read_method_callee_helper<'tcx> for reader::Decoder<'a> {
     }
 }
 
+impl<'tcx> tr for MethodOrigin<'tcx> {
+    fn tr(&self, dcx: &DecodeContext) -> MethodOrigin<'tcx> {
+        match *self {
+            ty::MethodStatic(did) => ty::MethodStatic(did.tr(dcx)),
+            ty::MethodStaticClosure(did) => {
+                ty::MethodStaticClosure(did.tr(dcx))
+            }
+            ty::MethodTypeParam(ref mp) => {
+                ty::MethodTypeParam(
+                    ty::MethodParam {
+                        // def-id is already translated when we read it out
+                        trait_ref: mp.trait_ref.clone(),
+                        method_num: mp.method_num,
+                        impl_def_id: mp.impl_def_id.tr(dcx),
+                    }
+                )
+            }
+            ty::MethodTraitObject(ref mo) => {
+                ty::MethodTraitObject(
+                    ty::MethodObject {
+                        trait_ref: mo.trait_ref.clone(),
+                        .. *mo
+                    }
+                )
+            }
+        }
+    }
+}
+
 pub fn encode_closure_kind(ebml_w: &mut Encoder, kind: ty::ClosureKind) {
     kind.encode(ebml_w).unwrap();
 }
@@ -1437,10 +1473,10 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
                            -> subst::Substs<'tcx> {
         self.read_opaque(|this, doc| {
             Ok(tydecode::parse_substs_data(doc.data,
-                                           dcx.cdata.cnum,
-                                           doc.start,
-                                           dcx.tcx,
-                                           |s, a| this.convert_def_id(dcx, s, a)))
+                                        dcx.cdata.cnum,
+                                        doc.start,
+                                        dcx.tcx,
+                                        |s, a| this.convert_def_id(dcx, s, a)))
         }).unwrap()
     }
 
@@ -1581,7 +1617,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
                       -> ast::DefId {
         let r = match source {
             NominalType | TypeWithId | RegionParameter => dcx.tr_def_id(did),
-            ClosureSource => dcx.tr_intern_def_id(did)
+            TypeParameter | ClosureSource => dcx.tr_intern_def_id(did)
         };
         debug!("convert_def_id(source={:?}, did={:?})={:?}", source, did, r);
         return r;

trunk/src/librustc/middle/ty.rs

@@ -814,7 +814,6 @@ bitflags! {
         const HAS_REGIONS       = 1 << 5,
         const HAS_TY_ERR        = 1 << 6,
         const HAS_PROJECTION    = 1 << 7,
-        const HAS_TY_CLOSURE    = 1 << 8,
         const NEEDS_SUBST       = TypeFlags::HAS_PARAMS.bits |
                                   TypeFlags::HAS_SELF.bits |
                                   TypeFlags::HAS_REGIONS.bits,
@@ -986,9 +985,6 @@ pub fn type_needs_infer(ty: Ty) -> bool {
 pub fn type_has_projection(ty: Ty) -> bool {
     ty.flags.get().intersects(TypeFlags::HAS_PROJECTION)
 }
-pub fn type_has_ty_closure(ty: Ty) -> bool {
-    ty.flags.get().intersects(TypeFlags::HAS_TY_CLOSURE)
-}
 
 pub fn type_has_late_bound_regions(ty: Ty) -> bool {
     ty.flags.get().intersects(TypeFlags::HAS_RE_LATE_BOUND)
@@ -2964,7 +2960,6 @@ impl FlagComputation {
             }
 
             &ty_closure(_, substs) => {
-                self.add_flags(TypeFlags::HAS_TY_CLOSURE);
                 self.add_substs(substs);
             }
 

trunk/src/librustc/util/ppaux.rs

@@ -304,18 +304,11 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
         s
     }
 
-    fn closure_to_string<'tcx>(cx: &ctxt<'tcx>,
-                               cty: &ty::ClosureTy<'tcx>,
-                               did: &ast::DefId)
-                               -> String {
+    fn closure_to_string<'tcx>(cx: &ctxt<'tcx>, cty: &ty::ClosureTy<'tcx>) -> String {
         let mut s = String::new();
         s.push_str("[closure");
         push_sig_to_string(cx, &mut s, '(', ')', &cty.sig);
-        if cx.sess.verbose() {
-            s.push_str(&format!(" id={:?}]", did));
-        } else {
-            s.push(']');
-        }
+        s.push(']');
         s
     }
 
@@ -414,20 +407,13 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
         ty_closure(ref did, substs) => {
             let closure_tys = cx.closure_tys.borrow();
             closure_tys.get(did).map(|closure_type| {
-                closure_to_string(cx, &closure_type.subst(cx, substs), did)
+                closure_to_string(cx, &closure_type.subst(cx, substs))
             }).unwrap_or_else(|| {
-                let id_str = if cx.sess.verbose() {
-                    format!(" id={:?}", did)
-                } else {
-                    "".to_owned()
-                };
-
-
                 if did.krate == ast::LOCAL_CRATE {
                     let span = cx.map.span(did.node);
-                    format!("[closure {}{}]", span.repr(cx), id_str)
+                    format!("[closure {}]", span.repr(cx))
                 } else {
-                    format!("[closure{}]", id_str)
+                    format!("[closure]")
                 }
             })
         }

trunk/src/librustc_resolve/lib.rs

@@ -3206,11 +3206,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         NoSuggestion
     }
 
-    fn find_best_match_for_name(&mut self, name: &str) -> Option<String> {
+    fn find_best_match_for_name(&mut self, name: &str, max_distance: usize)
+                                -> Option<String> {
+        let this = &mut *self;
+
         let mut maybes: Vec<token::InternedString> = Vec::new();
         let mut values: Vec<usize> = Vec::new();
 
-        for rib in self.value_ribs.iter().rev() {
+        for rib in this.value_ribs.iter().rev() {
             for (&k, _) in &rib.bindings {
                 maybes.push(token::get_name(k));
                 values.push(usize::MAX);
@@ -3226,12 +3229,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             }
         }
 
-        // As a loose rule to avoid obviously incorrect suggestions, clamp the
-        // maximum edit distance we will accept for a suggestion to one third of
-        // the typo'd name's length.
-        let max_distance = std::cmp::max(name.len(), 3) / 3;
-
         if !values.is_empty() &&
+            values[smallest] != usize::MAX &&
+            values[smallest] < name.len() + 2 &&
             values[smallest] <= max_distance &&
             name != &maybes[smallest][..] {
 
@@ -3357,7 +3357,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                     NoSuggestion => {
                                         // limit search to 5 to reduce the number
                                         // of stupid suggestions
-                                        self.find_best_match_for_name(&path_name)
+                                        self.find_best_match_for_name(&path_name, 5)
                                                             .map_or("".to_string(),
                                                                     |x| format!("`{}`", x))
                                     }

trunk/src/librustc_trans/trans/callee.rs

@@ -117,8 +117,9 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr)
             _ => {
                 bcx.tcx().sess.span_bug(
                     expr.span,
-                    &format!("type of callee is neither bare-fn nor closure: {}",
-                             bcx.ty_to_string(datum.ty)));
+                    &format!("type of callee is neither bare-fn nor closure: \
+                             {}",
+                            bcx.ty_to_string(datum.ty)));
             }
         }
     }
@@ -505,9 +506,6 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>(
         false
     };
 
-    debug!("trans_fn_ref_with_substs({}) must_monomorphise: {}",
-           def_id.repr(tcx), must_monomorphise);
-
     // Create a monomorphic version of generic functions
     if must_monomorphise {
         // Should be either intra-crate or inlined.