---

yaml
---
r: 63135
b: refs/heads/snap-stage3
c: 90ec422
h: refs/heads/master
i:
  63133: f068b94
  63131: 5a20f84
  63127: 849790a
  63119: adf19db
  63103: cd6fe44
v: v3

Author: bill-myers

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 470bf0dfb362e7494cfddf4e7d443e1264dfdf2f
+refs/heads/snap-stage3: 90ec4228bef1f7aa9612ddff03d21f7a260d4441
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/arc.rs

@@ -263,7 +263,7 @@ impl Drop for PoisonOnFail {
 
 fn PoisonOnFail<'r>(failed: &'r mut bool) -> PoisonOnFail {
     PoisonOnFail {
-        failed: failed
+        failed: ptr::to_mut_unsafe_ptr(failed)
     }
 }
 

branches/snap-stage3/src/libextra/ebml.rs

@@ -93,14 +93,6 @@ pub mod reader {
         pub fn get(&self, tag: uint) -> Doc {
             get_doc(*self, tag)
         }
-
-        pub fn as_str_slice<'a>(&'a self) -> &'a str {
-            str::from_bytes_slice(self.data.slice(self.start, self.end))
-        }
-
-        pub fn as_str(&self) -> ~str {
-            self.as_str_slice().to_owned()
-        }
     }
 
     struct Res {
@@ -247,10 +239,15 @@ pub mod reader {
         return true;
     }
 
+    pub fn doc_data(d: Doc) -> ~[u8] {
+        vec::slice::<u8>(*d.data, d.start, d.end).to_vec()
+    }
+
     pub fn with_doc_data<T>(d: Doc, f: &fn(x: &[u8]) -> T) -> T {
         f(vec::slice(*d.data, d.start, d.end))
     }
 
+    pub fn doc_as_str(d: Doc) -> ~str { str::from_bytes(doc_data(d)) }
 
     pub fn doc_as_u8(d: Doc) -> u8 {
         assert_eq!(d.end, d.start + 1u);
@@ -297,7 +294,7 @@ pub mod reader {
 
                 if r_tag == (EsLabel as uint) {
                     self.pos = r_doc.end;
-                    let str = r_doc.as_str_slice();
+                    let str = doc_as_str(r_doc);
                     if lbl != str {
                         fail!("Expected label %s but found %s", lbl, str);
                     }
@@ -418,9 +415,7 @@ pub mod reader {
         fn read_char(&mut self) -> char {
             doc_as_u32(self.next_doc(EsChar)) as char
         }
-        fn read_str(&mut self) -> ~str {
-            self.next_doc(EsStr).as_str()
-        }
+        fn read_str(&mut self) -> ~str { doc_as_str(self.next_doc(EsStr)) }
 
         // Compound types:
         fn read_enum<T>(&mut self,

branches/snap-stage3/src/librustc/lib/llvm.rs

@@ -2117,7 +2117,8 @@ pub fn struct_tys(struct_ty: TypeRef) -> ~[TypeRef] {
             return ~[];
         }
         let mut elts = vec::from_elem(n_elts, ptr::null());
-        llvm::LLVMGetStructElementTypes(struct_ty, &mut elts[0]);
+        llvm::LLVMGetStructElementTypes(
+            struct_ty, ptr::to_mut_unsafe_ptr(&mut elts[0]));
         return elts;
     }
 }

branches/snap-stage3/src/librustc/metadata/decoder.rs

@@ -162,18 +162,19 @@ fn item_visibility(item: ebml::Doc) -> ast::visibility {
 
 fn item_method_sort(item: ebml::Doc) -> char {
     for reader::tagged_docs(item, tag_item_trait_method_sort) |doc| {
-        return doc.as_str_slice()[0] as char;
+        return str::from_bytes(reader::doc_data(doc))[0] as char;
     }
     return 'r';
 }
 
 fn item_symbol(item: ebml::Doc) -> ~str {
-    reader::get_doc(item, tag_items_data_item_symbol).as_str()
+    let sym = reader::get_doc(item, tag_items_data_item_symbol);
+    return str::from_bytes(reader::doc_data(sym));
 }
 
 fn item_parent_item(d: ebml::Doc) -> Option<ast::def_id> {
     for reader::tagged_docs(d, tag_items_data_parent_item) |did| {
-        return Some(reader::with_doc_data(did, parse_def_id));
+        return Some(reader::with_doc_data(did, |d| parse_def_id(d)));
     }
     None
 }
@@ -194,7 +195,8 @@ fn item_reqd_and_translated_parent_item(cnum: ast::crate_num,
 
 fn item_def_id(d: ebml::Doc, cdata: cmd) -> ast::def_id {
     let tagdoc = reader::get_doc(d, tag_def_id);
-    return translate_def_id(cdata, reader::with_doc_data(tagdoc, parse_def_id));
+    return translate_def_id(cdata, reader::with_doc_data(tagdoc,
+                                                    |d| parse_def_id(d)));
 }
 
 fn each_reexport(d: ebml::Doc, f: &fn(ebml::Doc) -> bool) -> bool {
@@ -208,19 +210,19 @@ fn each_reexport(d: ebml::Doc, f: &fn(ebml::Doc) -> bool) -> bool {
 
 fn variant_disr_val(d: ebml::Doc) -> Option<int> {
     do reader::maybe_get_doc(d, tag_disr_val).chain |val_doc| {
-        do reader::with_doc_data(val_doc) |data| { int::parse_bytes(data, 10u) }
+        int::parse_bytes(reader::doc_data(val_doc), 10u)
     }
 }
 
 fn doc_type(doc: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::t {
     let tp = reader::get_doc(doc, tag_items_data_item_type);
-    parse_ty_data(*tp.data, cdata.cnum, tp.start, tcx,
+    parse_ty_data(tp.data, cdata.cnum, tp.start, tcx,
                   |_, did| translate_def_id(cdata, did))
 }
 
 fn doc_method_fty(doc: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::BareFnTy {
     let tp = reader::get_doc(doc, tag_item_method_fty);
-    parse_bare_fn_ty_data(*tp.data, cdata.cnum, tp.start, tcx,
+    parse_bare_fn_ty_data(tp.data, cdata.cnum, tp.start, tcx,
                           |_, did| translate_def_id(cdata, did))
 }
 
@@ -229,7 +231,7 @@ fn doc_transformed_self_ty(doc: ebml::Doc,
                            cdata: cmd) -> Option<ty::t>
 {
     do reader::maybe_get_doc(doc, tag_item_method_transformed_self_ty).map |tp| {
-        parse_ty_data(*tp.data, cdata.cnum, tp.start, tcx,
+        parse_ty_data(tp.data, cdata.cnum, tp.start, tcx,
                       |_, did| translate_def_id(cdata, did))
     }
 }
@@ -240,7 +242,7 @@ pub fn item_type(_item_id: ast::def_id, item: ebml::Doc,
 }
 
 fn doc_trait_ref(doc: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::TraitRef {
-    parse_trait_ref_data(*doc.data, cdata.cnum, doc.start, tcx,
+    parse_trait_ref_data(doc.data, cdata.cnum, doc.start, tcx,
                          |_, did| translate_def_id(cdata, did))
 }
 
@@ -255,7 +257,7 @@ fn item_ty_param_defs(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd,
     let mut bounds = ~[];
     for reader::tagged_docs(item, tag) |p| {
         let bd = parse_type_param_def_data(
-            *p.data, p.start, cdata.cnum, tcx,
+            p.data, p.start, cdata.cnum, tcx,
             |_, did| translate_def_id(cdata, did));
         bounds.push(bd);
     }
@@ -280,7 +282,7 @@ fn enum_variant_ids(item: ebml::Doc, cdata: cmd) -> ~[ast::def_id] {
     let mut ids: ~[ast::def_id] = ~[];
     let v = tag_items_data_item_variant;
     for reader::tagged_docs(item, v) |p| {
-        let ext = reader::with_doc_data(p, parse_def_id);
+        let ext = reader::with_doc_data(p, |d| parse_def_id(d));
         ids.push(ast::def_id { crate: cdata.cnum, node: ext.node });
     };
     return ids;
@@ -295,10 +297,10 @@ fn item_path(item_doc: ebml::Doc) -> ast_map::path {
     let mut result = vec::with_capacity(len);
     for reader::docs(path_doc) |tag, elt_doc| {
         if tag == tag_path_elt_mod {
-            let str = elt_doc.as_str_slice();
+            let str = reader::doc_as_str(elt_doc);
             result.push(ast_map::path_mod(token::str_to_ident(str)));
         } else if tag == tag_path_elt_name {
-            let str = elt_doc.as_str_slice();
+            let str = reader::doc_as_str(elt_doc);
             result.push(ast_map::path_name(token::str_to_ident(str)));
         } else {
             // ignore tag_path_len element
@@ -310,10 +312,12 @@ fn item_path(item_doc: ebml::Doc) -> ast_map::path {
 
 fn item_name(intr: @ident_interner, item: ebml::Doc) -> ast::ident {
     let name = reader::get_doc(item, tag_paths_data_name);
-    let string = name.as_str_slice();
-    match intr.find_equiv(&StringRef(string)) {
-        None => token::str_to_ident(string),
-        Some(val) => ast::new_ident(val),
+    do reader::with_doc_data(name) |data| {
+        let string = str::from_bytes_slice(data);
+        match intr.find_equiv(&StringRef(string)) {
+            None => token::str_to_ident(string),
+            Some(val) => ast::new_ident(val),
+        }
     }
 }
 
@@ -409,9 +413,15 @@ pub fn get_impl_trait(cdata: cmd,
                        tcx: ty::ctxt) -> Option<@ty::TraitRef>
 {
     let item_doc = lookup_item(id, cdata.data);
-    do reader::maybe_get_doc(item_doc, tag_item_trait_ref).map |&tp| {
-        @doc_trait_ref(tp, tcx, cdata)
-    }
+    let mut result = None;
+    for reader::tagged_docs(item_doc, tag_item_trait_ref) |tp| {
+        let trait_ref =
+            @parse_trait_ref_data(tp.data, cdata.cnum, tp.start, tcx,
+                                  |_, did| translate_def_id(cdata, did));
+        result = Some(trait_ref);
+        break;
+    };
+    result
 }
 
 pub fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
@@ -420,7 +430,7 @@ pub fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
     let mut found = None;
     for reader::tagged_docs(find_item(id, items), tag_item_impl_method)
         |mid| {
-            let m_did = reader::with_doc_data(mid, parse_def_id);
+            let m_did = reader::with_doc_data(mid, |d| parse_def_id(d));
             if item_name(intr, find_item(m_did.node, items)) == name {
                 found = Some(translate_def_id(cdata, m_did));
             }
@@ -503,17 +513,19 @@ pub fn each_path(intr: @ident_interner,
             let def_id_doc =
                 reader::get_doc(reexport_doc,
                                 tag_items_data_item_reexport_def_id);
-            let def_id = reader::with_doc_data(def_id_doc, parse_def_id);
+            let def_id =
+                reader::with_doc_data(def_id_doc,
+                                      |d| parse_def_id(d));
             let def_id = translate_def_id(cdata, def_id);
 
             let reexport_name_doc =
                 reader::get_doc(reexport_doc,
                                 tag_items_data_item_reexport_name);
-            let reexport_name = reexport_name_doc.as_str_slice();
+            let reexport_name = reader::doc_as_str(reexport_name_doc);
 
             let reexport_path;
             if path_is_empty {
-                reexport_path = reexport_name.to_owned();
+                reexport_path = reexport_name;
             } else {
                 reexport_path = path + "::" + reexport_name;
             }
@@ -634,7 +646,7 @@ fn get_explicit_self(item: ebml::Doc) -> ast::explicit_self_ {
     }
 
     let explicit_self_doc = reader::get_doc(item, tag_item_trait_method_explicit_self);
-    let string = explicit_self_doc.as_str_slice();
+    let string = reader::doc_as_str(explicit_self_doc);
 
     let explicit_self_kind = string[0];
     match explicit_self_kind as char {
@@ -656,7 +668,7 @@ fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc,
                      base_tps: uint) -> ~[@resolve::MethodInfo] {
     let mut rslt = ~[];
     for reader::tagged_docs(item, tag_item_impl_method) |doc| {
-        let m_did = reader::with_doc_data(doc, parse_def_id);
+        let m_did = reader::with_doc_data(doc, |d| parse_def_id(d));
         let mth_item = lookup_item(m_did.node, cdata.data);
         let explicit_self = get_explicit_self(mth_item);
         rslt.push(@resolve::MethodInfo {
@@ -678,7 +690,7 @@ pub fn get_impls_for_mod(intr: @ident_interner,
     let mod_item = lookup_item(m_id, data);
     let mut result = ~[];
     for reader::tagged_docs(mod_item, tag_mod_impl) |doc| {
-        let did = reader::with_doc_data(doc, parse_def_id);
+        let did = reader::with_doc_data(doc, |d| parse_def_id(d));
         let local_did = translate_def_id(cdata, did);
         debug!("(get impls for mod) getting did %? for '%?'",
                local_did, name);
@@ -819,7 +831,7 @@ pub fn get_type_name_if_impl(cdata: cmd,
     }
 
     for reader::tagged_docs(item, tag_item_impl_type_basename) |doc| {
-        return Some(token::str_to_ident(doc.as_str_slice()));
+        return Some(token::str_to_ident(str::from_bytes(reader::doc_data(doc))));
     }
 
     return None;
@@ -841,7 +853,7 @@ pub fn get_static_methods_if_impl(intr: @ident_interner,
 
     let mut impl_method_ids = ~[];
     for reader::tagged_docs(item, tag_item_impl_method) |impl_method_doc| {
-        impl_method_ids.push(reader::with_doc_data(impl_method_doc, parse_def_id));
+        impl_method_ids.push(parse_def_id(reader::doc_data(impl_method_doc)));
     }
 
     let mut static_impl_methods = ~[];
@@ -938,13 +950,12 @@ fn family_names_type(fam: Family) -> bool {
 }
 
 fn read_path(d: ebml::Doc) -> (~str, uint) {
-    do reader::with_doc_data(d) |desc| {
-        let pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint;
-        let pathbytes = desc.slice(4u, desc.len());
-        let path = str::from_bytes(pathbytes);
+    let desc = reader::doc_data(d);
+    let pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint;
+    let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc));
+    let path = str::from_bytes(pathbytes);
 
-        (path, pos)
-    }
+    (path, pos)
 }
 
 fn describe_def(items: ebml::Doc, id: ast::def_id) -> ~str {
@@ -985,21 +996,21 @@ fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
     let mut items: ~[@ast::meta_item] = ~[];
     for reader::tagged_docs(md, tag_meta_item_word) |meta_item_doc| {
         let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = nd.as_str();
+        let n = str::from_bytes(reader::doc_data(nd));
         items.push(attr::mk_word_item(@n));
     };
     for reader::tagged_docs(md, tag_meta_item_name_value) |meta_item_doc| {
         let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
         let vd = reader::get_doc(meta_item_doc, tag_meta_item_value);
-        let n = nd.as_str();
-        let v = vd.as_str();
+        let n = str::from_bytes(reader::doc_data(nd));
+        let v = str::from_bytes(reader::doc_data(vd));
         // FIXME (#623): Should be able to decode meta_name_value variants,
         // but currently the encoder just drops them
         items.push(attr::mk_name_value_item_str(@n, @v));
     };
     for reader::tagged_docs(md, tag_meta_item_list) |meta_item_doc| {
         let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = nd.as_str();
+        let n = str::from_bytes(reader::doc_data(nd));
         let subitems = get_meta_items(meta_item_doc);
         items.push(attr::mk_list_item(@n, subitems));
     };
@@ -1068,7 +1079,7 @@ pub fn get_crate_deps(data: @~[u8]) -> ~[crate_dep] {
     let depsdoc = reader::get_doc(cratedoc, tag_crate_deps);
     let mut crate_num = 1;
     fn docstr(doc: ebml::Doc, tag_: uint) -> ~str {
-        reader::get_doc(doc, tag_).as_str()
+        str::from_bytes(reader::doc_data(reader::get_doc(doc, tag_)))
     }
     for reader::tagged_docs(depsdoc, tag_crate_dep) |depdoc| {
         deps.push(crate_dep {cnum: crate_num,
@@ -1095,7 +1106,7 @@ fn list_crate_deps(data: @~[u8], out: @io::Writer) {
 pub fn get_crate_hash(data: @~[u8]) -> @~str {
     let cratedoc = reader::Doc(data);
     let hashdoc = reader::get_doc(cratedoc, tag_crate_hash);
-    @hashdoc.as_str()
+    @str::from_bytes(reader::doc_data(hashdoc))
 }
 
 pub fn get_crate_vers(data: @~[u8]) -> @~str {
@@ -1150,7 +1161,7 @@ pub fn get_link_args_for_crate(cdata: cmd) -> ~[~str] {
     let link_args = reader::get_doc(reader::Doc(cdata.data), tag_link_args);
     let mut result = ~[];
     for reader::tagged_docs(link_args, tag_link_args_arg) |arg_doc| {
-        result.push(arg_doc.as_str());
+        result.push(reader::doc_as_str(arg_doc));
     }
     result
 }