---

yaml
---
r: 79837
b: refs/heads/try
c: 634bddd
h: refs/heads/master
i:
  79835: cbac60c
v: v3

Author: jbclements

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: ba9fa89bfb4aae53db93e9ecac31807af96356fc
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 54ae2800ffb30513f89ce13d27ac3c8d095d98ac
-refs/heads/try: 7820fb5ca99785c4812ad32be80998a2a4fb4213
+refs/heads/try: 634bddde0577b7630f39bcf7edf2f52e22982dd5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libextra/base64.rs

@@ -315,8 +315,11 @@ mod test {
         use std::vec;
 
         do 1000.times {
-            let times = task_rng().gen_uint_range(1, 100);
-            let v = vec::from_fn(times, |_| random::<u8>());
+            let v: ~[u8] = do vec::build |push| {
+                do task_rng().gen_uint_range(1, 100).times {
+                    push(random());
+                }
+            };
             assert_eq!(v.to_base64(STANDARD).from_base64().unwrap(), v);
         }
     }

branches/try/src/libextra/workcache.rs

@@ -12,15 +12,17 @@
 
 use digest::Digest;
 use json;
-use json::ToJson;
 use sha1::Sha1;
 use serialize::{Encoder, Encodable, Decoder, Decodable};
 use arc::{Arc,RWArc};
 use treemap::TreeMap;
+
 use std::cell::Cell;
 use std::comm::{PortOne, oneshot};
 use std::either::{Either, Left, Right};
-use std::{io, os, task};
+use std::io;
+use std::run;
+use std::task;
 
 /**
 *
@@ -105,27 +107,11 @@ impl WorkKey {
     }
 }
 
-// FIXME #8883: The key should be a WorkKey and not a ~str.
-// This is working around some JSON weirdness.
-#[deriving(Clone, Eq, Encodable, Decodable)]
-struct WorkMap(TreeMap<~str, KindMap>);
-
 #[deriving(Clone, Eq, Encodable, Decodable)]
-struct KindMap(TreeMap<~str, ~str>);
+struct WorkMap(TreeMap<WorkKey, ~str>);
 
 impl WorkMap {
     fn new() -> WorkMap { WorkMap(TreeMap::new()) }
-
-    fn insert_work_key(&mut self, k: WorkKey, val: ~str) {
-        let WorkKey { kind, name } = k;
-        match self.find_mut(&name) {
-            Some(&KindMap(ref mut m)) => { m.insert(kind, val); return; }
-            None => ()
-        }
-        let mut new_map = TreeMap::new();
-        new_map.insert(kind, val);
-        self.insert(name, KindMap(new_map));
-    }
 }
 
 struct Database {
@@ -137,15 +123,11 @@ struct Database {
 impl Database {
 
     pub fn new(p: Path) -> Database {
-        let mut rslt = Database {
+        Database {
             db_filename: p,
             db_cache: TreeMap::new(),
             db_dirty: false
-        };
-        if os::path_exists(&rslt.db_filename) {
-            rslt.load();
         }
-        rslt
     }
 
     pub fn prepare(&self,
@@ -172,41 +154,6 @@ impl Database {
         self.db_cache.insert(k,v);
         self.db_dirty = true
     }
-
-    // FIXME #4330: This should have &mut self and should set self.db_dirty to false.
-    fn save(&self) {
-        let f = io::file_writer(&self.db_filename, [io::Create, io::Truncate]).unwrap();
-        self.db_cache.to_json().to_pretty_writer(f);
-    }
-
-    fn load(&mut self) {
-        assert!(!self.db_dirty);
-        assert!(os::path_exists(&self.db_filename));
-        let f = io::file_reader(&self.db_filename);
-        match f {
-            Err(e) => fail!("Couldn't load workcache database %s: %s",
-                            self.db_filename.to_str(), e.to_str()),
-            Ok(r) =>
-                match json::from_reader(r) {
-                    Err(e) => fail!("Couldn't parse workcache database (from file %s): %s",
-                                    self.db_filename.to_str(), e.to_str()),
-                    Ok(r) => {
-                        let mut decoder = json::Decoder(r);
-                        self.db_cache = Decodable::decode(&mut decoder);
-                    }
-            }
-        }
-    }
-}
-
-// FIXME #4330: use &mut self here
-#[unsafe_destructor]
-impl Drop for Database {
-    fn drop(&self) {
-        if self.db_dirty {
-            self.save();
-        }
-    }
 }
 
 struct Logger {
@@ -225,20 +172,12 @@ impl Logger {
     }
 }
 
-type FreshnessMap = TreeMap<~str,extern fn(&str,&str)->bool>;
-
 #[deriving(Clone)]
 struct Context {
     db: RWArc<Database>,
     logger: RWArc<Logger>,
     cfg: Arc<json::Object>,
-    /// Map from kinds (source, exe, url, etc.) to a freshness function.
-    /// The freshness function takes a name (e.g. file path) and value
-    /// (e.g. hash of file contents) and determines whether it's up-to-date.
-    /// For example, in the file case, this would read the file off disk,
-    /// hash it, and return the result of comparing the given hash and the
-    /// read hash for equality.
-    freshness: Arc<FreshnessMap>
+    freshness: Arc<TreeMap<~str,extern fn(&str,&str)->bool>>
 }
 
 struct Prep<'self> {
@@ -266,7 +205,6 @@ fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str {
 
 // FIXME(#5121)
 fn json_decode<T:Decodable<json::Decoder>>(s: &str) -> T {
-    debug!("json decoding: %s", s);
     do io::with_str_reader(s) |rdr| {
         let j = json::from_reader(rdr).unwrap();
         let mut decoder = json::Decoder(j);
@@ -292,18 +230,11 @@ impl Context {
     pub fn new(db: RWArc<Database>,
                lg: RWArc<Logger>,
                cfg: Arc<json::Object>) -> Context {
-        Context::new_with_freshness(db, lg, cfg, Arc::new(TreeMap::new()))
-    }
-
-    pub fn new_with_freshness(db: RWArc<Database>,
-                              lg: RWArc<Logger>,
-                              cfg: Arc<json::Object>,
-                              freshness: Arc<FreshnessMap>) -> Context {
         Context {
             db: db,
             logger: lg,
             cfg: cfg,
-            freshness: freshness
+            freshness: Arc::new(TreeMap::new())
         }
     }
 
@@ -318,36 +249,6 @@ impl Context {
 
 }
 
-impl Exec {
-    pub fn discover_input(&mut self,
-                          dependency_kind: &str,
-                          dependency_name: &str,
-                          dependency_val: &str) {
-        debug!("Discovering input %s %s %s", dependency_kind, dependency_name, dependency_val);
-        self.discovered_inputs.insert_work_key(WorkKey::new(dependency_kind, dependency_name),
-                                 dependency_val.to_owned());
-    }
-    pub fn discover_output(&mut self,
-                           dependency_kind: &str,
-                           dependency_name: &str,
-                           dependency_val: &str) {
-        debug!("Discovering output %s %s %s", dependency_kind, dependency_name, dependency_val);
-        self.discovered_outputs.insert_work_key(WorkKey::new(dependency_kind, dependency_name),
-                                 dependency_val.to_owned());
-    }
-
-    // returns pairs of (kind, name)
-    pub fn lookup_discovered_inputs(&self) -> ~[(~str, ~str)] {
-        let mut rs = ~[];
-        for (k, v) in self.discovered_inputs.iter() {
-            for (k1, _) in v.iter() {
-                rs.push((k1.clone(), k.clone()));
-            }
-        }
-        rs
-    }
-}
-
 impl<'self> Prep<'self> {
     fn new(ctxt: &'self Context, fn_name: &'self str) -> Prep<'self> {
         Prep {
@@ -356,30 +257,18 @@ impl<'self> Prep<'self> {
             declared_inputs: WorkMap::new()
         }
     }
-
-    pub fn lookup_declared_inputs(&self) -> ~[~str] {
-        let mut rs = ~[];
-        for (_, v) in self.declared_inputs.iter() {
-            for (inp, _) in v.iter() {
-                rs.push(inp.clone());
-            }
-        }
-        rs
-    }
 }
 
 impl<'self> Prep<'self> {
-    pub fn declare_input(&mut self, kind: &str, name: &str, val: &str) {
-        debug!("Declaring input %s %s %s", kind, name, val);
-        self.declared_inputs.insert_work_key(WorkKey::new(kind, name),
+    fn declare_input(&mut self, kind:&str, name:&str, val:&str) {
+        self.declared_inputs.insert(WorkKey::new(kind, name),
                                  val.to_owned());
     }
 
     fn is_fresh(&self, cat: &str, kind: &str,
                 name: &str, val: &str) -> bool {
         let k = kind.to_owned();
         let f = self.ctxt.freshness.get().find(&k);
-        debug!("freshness for: %s/%s/%s/%s", cat, kind, name, val)
         let fresh = match f {
             None => fail!("missing freshness-function for '%s'", kind),
             Some(f) => (*f)(name, val)
@@ -397,31 +286,27 @@ impl<'self> Prep<'self> {
     }
 
     fn all_fresh(&self, cat: &str, map: &WorkMap) -> bool {
-        for (k_name, kindmap) in map.iter() {
-            for (k_kind, v) in kindmap.iter() {
-               if ! self.is_fresh(cat, *k_kind, *k_name, *v) {
-                  return false;
+        for (k, v) in map.iter() {
+            if ! self.is_fresh(cat, k.kind, k.name, *v) {
+                return false;
             }
-          }
         }
         return true;
     }
 
-    pub fn exec<T:Send +
+    fn exec<T:Send +
         Encodable<json::Encoder> +
         Decodable<json::Decoder>>(
-            &'self self, blk: ~fn(&mut Exec) -> T) -> T {
+            &'self self, blk: ~fn(&Exec) -> T) -> T {
         self.exec_work(blk).unwrap()
     }
 
     fn exec_work<T:Send +
         Encodable<json::Encoder> +
         Decodable<json::Decoder>>( // FIXME(#5121)
-            &'self self, blk: ~fn(&mut Exec) -> T) -> Work<'self, T> {
+            &'self self, blk: ~fn(&Exec) -> T) -> Work<'self, T> {
         let mut bo = Some(blk);
 
-        debug!("exec_work: looking up %s and %?", self.fn_name,
-               self.declared_inputs);
         let cached = do self.ctxt.db.read |db| {
             db.prepare(self.fn_name, &self.declared_inputs)
         };
@@ -431,26 +316,21 @@ impl<'self> Prep<'self> {
             if self.all_fresh("declared input",&self.declared_inputs) &&
                self.all_fresh("discovered input", disc_in) &&
                self.all_fresh("discovered output", disc_out) => {
-                debug!("Cache hit!");
-                debug!("Trying to decode: %? / %? / %?",
-                       disc_in, disc_out, *res);
                 Left(json_decode(*res))
             }
 
             _ => {
-                debug!("Cache miss!");
                 let (port, chan) = oneshot();
                 let blk = bo.take_unwrap();
                 let chan = Cell::new(chan);
 
-// What happens if the task fails?
                 do task::spawn {
-                    let mut exe = Exec {
+                    let exe = Exec {
                         discovered_inputs: WorkMap::new(),
                         discovered_outputs: WorkMap::new(),
                     };
                     let chan = chan.take();
-                    let v = blk(&mut exe);
+                    let v = blk(&exe);
                     chan.send((exe, v));
                 }
                 Right(port)
@@ -491,23 +371,17 @@ impl<'self, T:Send +
 }
 
 
-#[test]
+//#[test]
 fn test() {
     use std::io::WriterUtil;
-    use std::{os, run};
 
     let pth = Path("foo.c");
     {
         let r = io::file_writer(&pth, [io::Create]);
         r.unwrap().write_str("int main() { return 0; }");
     }
 
-    let db_path = os::self_exe_path().expect("workcache::test failed").pop().push("db.json");
-    if os::path_exists(&db_path) {
-        os::remove_file(&db_path);
-    }
-
-    let cx = Context::new(RWArc::new(Database::new(db_path)),
+    let cx = Context::new(RWArc::new(Database::new(Path("db.json"))),
                           RWArc::new(Logger::new()),
                           Arc::new(TreeMap::new()));
 

branches/try/src/librustc/middle/trans/_match.rs

@@ -671,7 +671,8 @@ fn enter_opt<'r>(bcx: @mut Block,
                     let mut reordered_patterns = ~[];
                     let r = ty::lookup_struct_fields(tcx, struct_id);
                     for field in r.iter() {
-                            match field_pats.iter().find(|p| p.ident == field.ident) {
+                            match field_pats.iter().find(|p| p.ident.name
+                                                         == field.ident.name) {
                                 None => reordered_patterns.push(dummy),
                                 Some(fp) => reordered_patterns.push(fp.pat)
                             }
@@ -752,7 +753,7 @@ fn enter_rec_or_struct<'r>(bcx: @mut Block,
             ast::PatStruct(_, ref fpats, _) => {
                 let mut pats = ~[];
                 for fname in fields.iter() {
-                    match fpats.iter().find(|p| p.ident == *fname) {
+                    match fpats.iter().find(|p| p.ident.name == fname.name) {
                         None => pats.push(dummy),
                         Some(pat) => pats.push(pat.pat)
                     }
@@ -1102,7 +1103,7 @@ fn collect_record_or_struct_fields(bcx: @mut Block,
     fn extend(idents: &mut ~[ast::Ident], field_pats: &[ast::FieldPat]) {
         for field_pat in field_pats.iter() {
             let field_ident = field_pat.ident;
-            if !idents.iter().any(|x| *x == field_ident) {
+            if !idents.iter().any(|x| x.name == field_ident.name) {
                 idents.push(field_ident);
             }
         }

branches/try/src/librustc/middle/trans/reflect.rs

@@ -256,7 +256,8 @@ impl Reflector {
               let fields = ty::struct_fields(tcx, did, substs);
               let mut named_fields = false;
               if !fields.is_empty() {
-                  named_fields = fields[0].ident != special_idents::unnamed_field;
+                  named_fields =
+                        fields[0].ident.name != special_idents::unnamed_field.name;
               }
 
               let extra = ~[self.c_slice(ty_to_str(tcx, t).to_managed()),