---

yaml
---
r: 95191
b: refs/heads/dist-snap
c: 03099e5
h: refs/heads/master
i:
  95189: e9831b1
  95187: c7311b2
  95183: 9b82ec3
v: v3

Author: Valloric

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: bae0ce2a69e7cef568279e2228cde3b2d225f880
+refs/heads/dist-snap: 03099e56789271c35e64c18542db192c086b586e
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/etc/get-snapshot.py

@@ -26,8 +26,6 @@ def unpack_snapshot(triple, dl_path):
     print("extracting " + p)
     tar.extract(p, download_unpack_base)
     tp = os.path.join(download_unpack_base, p)
-    if os.path.isdir(tp) and os.path.exists(fp):
-        continue
     shutil.move(tp, fp)
   tar.close()
   shutil.rmtree(download_unpack_base)

branches/dist-snap/src/librustc/middle/const_eval.rs

@@ -60,8 +60,6 @@ pub enum constness {
     non_const
 }
 
-type constness_cache = HashMap<ast::DefId, constness>;
-
 pub fn join(a: constness, b: constness) -> constness {
     match (a, b) {
       (integral_const, integral_const) => integral_const,
@@ -76,12 +74,102 @@ pub fn join_all<It: Iterator<constness>>(mut cs: It) -> constness {
     cs.fold(integral_const, |a, b| join(a, b))
 }
 
+pub fn classify(e: &Expr,
+                tcx: ty::ctxt)
+             -> constness {
+    let did = ast_util::local_def(e.id);
+    match tcx.ccache.find(&did) {
+      Some(&x) => x,
+      None => {
+        let cn =
+            match e.node {
+              ast::ExprLit(lit) => {
+                match lit.node {
+                  ast::lit_str(*) |
+                  ast::lit_float(*) => general_const,
+                  _ => integral_const
+                }
+              }
+
+              ast::ExprUnary(_, _, inner) |
+              ast::ExprParen(inner) => {
+                classify(inner, tcx)
+              }
+
+              ast::ExprBinary(_, _, a, b) => {
+                join(classify(a, tcx),
+                     classify(b, tcx))
+              }
+
+              ast::ExprTup(ref es) |
+              ast::ExprVec(ref es, ast::MutImmutable) => {
+                join_all(es.iter().map(|e| classify(*e, tcx)))
+              }
+
+              ast::ExprVstore(e, vstore) => {
+                  match vstore {
+                      ast::ExprVstoreSlice => classify(e, tcx),
+                      ast::ExprVstoreUniq |
+                      ast::ExprVstoreBox |
+                      ast::ExprVstoreMutBox |
+                      ast::ExprVstoreMutSlice => non_const
+                  }
+              }
+
+              ast::ExprStruct(_, ref fs, None) => {
+                let cs = do fs.iter().map |f| {
+                    classify(f.expr, tcx)
+                };
+                join_all(cs)
+              }
+
+              ast::ExprCast(base, _) => {
+                let ty = ty::expr_ty(tcx, e);
+                let base = classify(base, tcx);
+                if ty::type_is_integral(ty) {
+                    join(integral_const, base)
+                } else if ty::type_is_fp(ty) {
+                    join(general_const, base)
+                } else {
+                    non_const
+                }
+              }
+
+              ast::ExprField(base, _, _) => {
+                classify(base, tcx)
+              }
+
+              ast::ExprIndex(_, base, idx) => {
+                join(classify(base, tcx),
+                     classify(idx, tcx))
+              }
+
+              ast::ExprAddrOf(ast::MutImmutable, base) => {
+                classify(base, tcx)
+              }
+
+              // FIXME: (#3728) we can probably do something CCI-ish
+              // surrounding nonlocal constants. But we don't yet.
+              ast::ExprPath(_) => {
+                lookup_constness(tcx, e)
+              }
+
+              ast::ExprRepeat(*) => general_const,
+
+              _ => non_const
+            };
+        tcx.ccache.insert(did, cn);
+        cn
+      }
+    }
+}
+
 pub fn lookup_const(tcx: ty::ctxt, e: &Expr) -> Option<@Expr> {
     match tcx.def_map.find(&e.id) {
-        Some(&ast::DefStatic(def_id, false)) =>
-            lookup_const_by_id(tcx, def_id),
-        Some(&ast::DefVariant(enum_def, variant_def, _)) =>
-            lookup_variant_by_id(tcx, enum_def, variant_def),
+        Some(&ast::DefStatic(def_id, false)) => lookup_const_by_id(tcx, def_id),
+        Some(&ast::DefVariant(enum_def, variant_def, _)) => lookup_variant_by_id(tcx,
+                                                                               enum_def,
+                                                                               variant_def),
         _ => None
     }
 }
@@ -111,18 +199,14 @@ pub fn lookup_variant_by_id(tcx: ty::ctxt,
             Some(_) => None
         }
     } else {
-        match tcx.extern_const_variants.find(&variant_def) {
-            Some(&e) => return e,
-            None => {}
-        }
         let maps = astencode::Maps {
             root_map: @mut HashMap::new(),
             method_map: @mut HashMap::new(),
             vtable_map: @mut HashMap::new(),
             write_guard_map: @mut HashSet::new(),
             capture_map: @mut HashMap::new()
         };
-        let e = match csearch::maybe_get_item_ast(tcx, enum_def,
+        match csearch::maybe_get_item_ast(tcx, enum_def,
             |a, b, c, d| astencode::decode_inlined_item(a,
                                                         b,
                                                         maps,
@@ -135,9 +219,7 @@ pub fn lookup_variant_by_id(tcx: ty::ctxt,
                 _ => None
             },
             _ => None
-        };
-        tcx.extern_const_variants.insert(variant_def, e);
-        return e;
+        }
     }
 }
 
@@ -154,136 +236,49 @@ pub fn lookup_const_by_id(tcx: ty::ctxt,
             Some(_) => None
         }
     } else {
-        match tcx.extern_const_statics.find(&def_id) {
-            Some(&e) => return e,
-            None => {}
-        }
         let maps = astencode::Maps {
             root_map: @mut HashMap::new(),
             method_map: @mut HashMap::new(),
             vtable_map: @mut HashMap::new(),
             write_guard_map: @mut HashSet::new(),
             capture_map: @mut HashMap::new()
         };
-        let e = match csearch::maybe_get_item_ast(tcx, def_id,
+        match csearch::maybe_get_item_ast(tcx, def_id,
             |a, b, c, d| astencode::decode_inlined_item(a, b, maps, c, d)) {
             csearch::found(ast::ii_item(item)) => match item.node {
                 item_static(_, ast::MutImmutable, const_expr) => Some(const_expr),
                 _ => None
             },
             _ => None
-        };
-        tcx.extern_const_statics.insert(def_id, e);
-        return e;
-    }
-}
-
-struct ConstEvalVisitor {
-    tcx: ty::ctxt,
-    ccache: constness_cache,
-}
-
-impl ConstEvalVisitor {
-    fn classify(&mut self, e: &Expr) -> constness {
-        let did = ast_util::local_def(e.id);
-        match self.ccache.find(&did) {
-            Some(&x) => return x,
-            None => {}
         }
-        let cn = match e.node {
-            ast::ExprLit(lit) => {
-                match lit.node {
-                    ast::lit_str(*) | ast::lit_float(*) => general_const,
-                    _ => integral_const
-                }
-            }
-
-            ast::ExprUnary(_, _, inner) | ast::ExprParen(inner) =>
-                self.classify(inner),
-
-            ast::ExprBinary(_, _, a, b) =>
-                join(self.classify(a), self.classify(b)),
-
-            ast::ExprTup(ref es) |
-            ast::ExprVec(ref es, ast::MutImmutable) =>
-                join_all(es.iter().map(|e| self.classify(*e))),
-
-            ast::ExprVstore(e, vstore) => {
-                match vstore {
-                    ast::ExprVstoreSlice => self.classify(e),
-                    ast::ExprVstoreUniq |
-                    ast::ExprVstoreBox |
-                    ast::ExprVstoreMutBox |
-                    ast::ExprVstoreMutSlice => non_const
-                }
-            }
-
-            ast::ExprStruct(_, ref fs, None) => {
-                let cs = do fs.iter().map |f| {
-                    self.classify(f.expr)
-                };
-                join_all(cs)
-            }
-
-            ast::ExprCast(base, _) => {
-                let ty = ty::expr_ty(self.tcx, e);
-                let base = self.classify(base);
-                if ty::type_is_integral(ty) {
-                    join(integral_const, base)
-                } else if ty::type_is_fp(ty) {
-                    join(general_const, base)
-                } else {
-                    non_const
-                }
-            }
-
-            ast::ExprField(base, _, _) => self.classify(base),
-
-            ast::ExprIndex(_, base, idx) =>
-                join(self.classify(base), self.classify(idx)),
-
-            ast::ExprAddrOf(ast::MutImmutable, base) => self.classify(base),
-
-            // FIXME: (#3728) we can probably do something CCI-ish
-            // surrounding nonlocal constants. But we don't yet.
-            ast::ExprPath(_) => self.lookup_constness(e),
-
-            ast::ExprRepeat(*) => general_const,
-
-            _ => non_const
-        };
-        self.ccache.insert(did, cn);
-        cn
     }
+}
 
-    fn lookup_constness(&self, e: &Expr) -> constness {
-        match lookup_const(self.tcx, e) {
-            Some(rhs) => {
-                let ty = ty::expr_ty(self.tcx, rhs);
-                if ty::type_is_integral(ty) {
-                    integral_const
-                } else {
-                    general_const
-                }
+pub fn lookup_constness(tcx: ty::ctxt, e: &Expr) -> constness {
+    match lookup_const(tcx, e) {
+        Some(rhs) => {
+            let ty = ty::expr_ty(tcx, rhs);
+            if ty::type_is_integral(ty) {
+                integral_const
+            } else {
+                general_const
             }
-            None => non_const
         }
+        None => non_const
     }
-
 }
 
+struct ConstEvalVisitor { tcx: ty::ctxt }
+
 impl Visitor<()> for ConstEvalVisitor {
     fn visit_expr_post(&mut self, e:@Expr, _:()) {
-        self.classify(e);
+        classify(e, self.tcx);
     }
 }
 
 pub fn process_crate(crate: &ast::Crate,
                      tcx: ty::ctxt) {
-    let mut v = ConstEvalVisitor {
-        tcx: tcx,
-        ccache: HashMap::new(),
-    };
+    let mut v = ConstEvalVisitor { tcx: tcx };
     visit::walk_crate(&mut v, crate, ());
     tcx.sess.abort_if_errors();
 }

branches/dist-snap/src/librustc/middle/ty.rs

@@ -290,6 +290,7 @@ struct ctxt_ {
     freevars: freevars::freevar_map,
     tcache: type_cache,
     rcache: creader_cache,
+    ccache: constness_cache,
     short_names_cache: @mut HashMap<t, @str>,
     needs_unwind_cleanup_cache: @mut HashMap<t, bool>,
     tc_cache: @mut HashMap<uint, TypeContents>,
@@ -345,11 +346,6 @@ struct ctxt_ {
     // The set of external traits whose implementations have been read. This
     // is used for lazy resolution of traits.
     populated_external_traits: @mut HashSet<ast::DefId>,
-
-    // These two caches are used by const_eval when decoding external statics
-    // and variants that are found.
-    extern_const_statics: @mut HashMap<ast::DefId, Option<@ast::Expr>>,
-    extern_const_variants: @mut HashMap<ast::DefId, Option<@ast::Expr>>,
 }
 
 pub enum tbox_flag {
@@ -901,6 +897,8 @@ pub struct ty_param_substs_and_ty {
 
 type type_cache = @mut HashMap<ast::DefId, ty_param_bounds_and_ty>;
 
+type constness_cache = @mut HashMap<ast::DefId, const_eval::constness>;
+
 pub type node_type_table = @mut HashMap<uint,t>;
 
 fn mk_rcache() -> creader_cache {
@@ -937,6 +935,7 @@ pub fn mk_ctxt(s: session::Session,
         freevars: freevars,
         tcache: @mut HashMap::new(),
         rcache: mk_rcache(),
+        ccache: @mut HashMap::new(),
         short_names_cache: new_ty_hash(),
         needs_unwind_cleanup_cache: new_ty_hash(),
         tc_cache: @mut HashMap::new(),
@@ -962,9 +961,6 @@ pub fn mk_ctxt(s: session::Session,
         impl_vtables: @mut HashMap::new(),
         populated_external_types: @mut HashSet::new(),
         populated_external_traits: @mut HashSet::new(),
-
-        extern_const_statics: @mut HashMap::new(),
-        extern_const_variants: @mut HashMap::new(),
      }
 }
 

branches/dist-snap/src/libstd/str.rs

@@ -16,7 +16,7 @@ String manipulation
 
 Rust's string type is one of the core primitive types of the language. While
 represented by the name `str`, the name `str` is not actually a valid type in
-Rust. Each string must also be decorated with its ownership. This means that
+Rust. Each string must also be decorated with how its ownership. This means that
 there are three common kinds of strings in rust:
 
 * `~str` - This is an owned string. This type obeys all of the normal semantics
@@ -26,7 +26,7 @@ there are three common kinds of strings in rust:
 
 * `@str` - This is a managed string. Similarly to `@T`, this type can be
            implicitly copied, and each implicit copy will increment the
-           reference count to the string. This means that there is not "true
+           reference count to the string. This means that there is no "true
            owner" of the string, and the string will be deallocated when the
            reference count reaches 0.