---

yaml
---
r: 7884
b: refs/heads/snap-stage3
c: fcb3814
h: refs/heads/master
v: v3

Author: jdm

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 0794195fbdb6efa34388dfdf3dfc968bbbf06215
+refs/heads/snap-stage3: fcb381410d59b89336a528103582a956334c9777
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/snap-stage3/AUTHORS.txt

@@ -5,7 +5,6 @@ Graydon Hoare <[email protected]>
 Other authors:
 
 Adam Bozanich <[email protected]>
-Aleksander Balicki <[email protected]>
 Andreas Gal <[email protected]>
 Austin Seipp <[email protected]>
 Ben Striegel <[email protected]>

branches/snap-stage3/mk/install.mk

@@ -5,12 +5,12 @@
 # Installation macro. Call with source directory as arg 1,
 # destination directory as arg 2, and filename/libname-glob as arg 3
 ifdef VERBOSE
- INSTALL = install -m755 -T $(1)/$(3) $(2)/$(3)
- INSTALL_LIB = install -m644 `ls -rt1 $(1)/$(3) | tail -1` $(2)/
+ INSTALL = cp $(1)/$(3) $(2)/$(3)
+ INSTALL_LIB = cp `ls -rt1 $(1)/$(3) | tail -1` $(2)/
 else
- INSTALL = $(Q)$(call E, install: $(2)/$(3)) && install -m755 -T $(1)/$(3) $(2)/$(3)
+ INSTALL = $(Q)$(call E, install: $(2)/$(3)) && cp $(1)/$(3) $(2)/$(3)
  INSTALL_LIB = $(Q)$(call E, install_lib: $(2)/$(3)) &&                    \
-	       install -m644 `ls -rt1 $(1)/$(3) | tail -1` $(2)/
+	       cp `ls -rt1 $(1)/$(3) | tail -1` $(2)/
 endif
 
 # The stage we install from

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

@@ -83,7 +83,7 @@ fn item_family(item: ebml::doc) -> u8 {
 
 fn item_symbol(item: ebml::doc) -> str {
     let sym = ebml::get_doc(item, tag_items_data_item_symbol);
-    ret str::from_bytes(ebml::doc_data(sym));
+    ret str::unsafe_from_bytes(ebml::doc_data(sym));
 }
 
 fn variant_enum_id(d: ebml::doc) -> ast::def_id {
@@ -162,7 +162,7 @@ fn enum_variant_ids(item: ebml::doc, cdata: cmd) -> [ast::def_id] {
 // definition the path refers to.
 fn resolve_path(path: [ast::ident], data: @[u8]) -> [ast::def_id] {
     fn eq_item(data: [u8], s: str) -> bool {
-        ret str::eq(str::from_bytes(data), s);
+        ret str::eq(str::unsafe_from_bytes(data), s);
     }
     let s = str::connect(path, "::");
     let md = ebml::new_doc(data);
@@ -178,7 +178,7 @@ fn resolve_path(path: [ast::ident], data: @[u8]) -> [ast::def_id] {
 
 fn item_name(item: ebml::doc) -> ast::ident {
     let name = ebml::get_doc(item, tag_paths_data_name);
-    str::from_bytes(ebml::doc_data(name))
+    str::unsafe_from_bytes(ebml::doc_data(name))
 }
 
 fn lookup_item_name(data: @[u8], id: ast::node_id) -> ast::ident {
@@ -325,7 +325,7 @@ fn read_path(d: ebml::doc) -> {path: str, pos: uint} {
     let desc = ebml::doc_data(d);
     let pos = ebml::be_uint_from_bytes(@desc, 0u, 4u);
     let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc));
-    let path = str::from_bytes(pathbytes);
+    let path = str::unsafe_from_bytes(pathbytes);
     ret {path: path, pos: pos};
 }
 
@@ -358,21 +358,21 @@ fn get_meta_items(md: ebml::doc) -> [@ast::meta_item] {
     let items: [@ast::meta_item] = [];
     ebml::tagged_docs(md, tag_meta_item_word) {|meta_item_doc|
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = str::from_bytes(ebml::doc_data(nd));
+        let n = str::unsafe_from_bytes(ebml::doc_data(nd));
         items += [attr::mk_word_item(n)];
     };
     ebml::tagged_docs(md, tag_meta_item_name_value) {|meta_item_doc|
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let vd = ebml::get_doc(meta_item_doc, tag_meta_item_value);
-        let n = str::from_bytes(ebml::doc_data(nd));
-        let v = str::from_bytes(ebml::doc_data(vd));
+        let n = str::unsafe_from_bytes(ebml::doc_data(nd));
+        let v = str::unsafe_from_bytes(ebml::doc_data(vd));
         // FIXME (#611): Should be able to decode meta_name_value variants,
         // but currently they can't be encoded
         items += [attr::mk_name_value_item_str(n, v)];
     };
     ebml::tagged_docs(md, tag_meta_item_list) {|meta_item_doc|
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = str::from_bytes(ebml::doc_data(nd));
+        let n = str::unsafe_from_bytes(ebml::doc_data(nd));
         let subitems = get_meta_items(meta_item_doc);
         items += [attr::mk_list_item(n, subitems)];
     };
@@ -427,7 +427,7 @@ fn get_crate_deps(data: @[u8]) -> [crate_dep] {
     let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
     let crate_num = 1;
     ebml::tagged_docs(depsdoc, tag_crate_dep) {|depdoc|
-        let depname = str::from_bytes(ebml::doc_data(depdoc));
+        let depname = str::unsafe_from_bytes(ebml::doc_data(depdoc));
         deps += [{cnum: crate_num, ident: depname}];
         crate_num += 1;
     };
@@ -447,7 +447,7 @@ fn list_crate_deps(data: @[u8], out: io::writer) {
 fn get_crate_hash(data: @[u8]) -> str {
     let cratedoc = ebml::new_doc(data);
     let hashdoc = ebml::get_doc(cratedoc, tag_crate_hash);
-    ret str::from_bytes(ebml::doc_data(hashdoc));
+    ret str::unsafe_from_bytes(ebml::doc_data(hashdoc));
 }
 
 fn list_crate_items(bytes: @[u8], md: ebml::doc, out: io::writer) {

branches/snap-stage3/src/comp/metadata/encoder.rs

@@ -661,7 +661,7 @@ fn encode_hash(ebml_w: ebml::writer, hash: str) {
     ebml::end_tag(ebml_w);
 }
 
-fn encode_metadata(cx: @crate_ctxt, crate: @crate) -> [u8] {
+fn encode_metadata(cx: @crate_ctxt, crate: @crate) -> str {
 
     let abbrevs = ty::new_ty_hash();
     let ecx = @{ccx: cx, type_abbrevs: abbrevs};
@@ -694,7 +694,7 @@ fn encode_metadata(cx: @crate_ctxt, crate: @crate) -> [u8] {
     // Pad this, since something (LLVM, presumably) is cutting off the
     // remaining % 4 bytes.
     buf_w.write([0u8, 0u8, 0u8, 0u8]);
-    io::mem_buffer_buf(buf)
+    io::mem_buffer_str(buf)
 }
 
 // Get the encoded string for a type

branches/snap-stage3/src/comp/metadata/tydecode.rs

@@ -39,7 +39,7 @@ fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) ->
    ast::ident {
     let rslt = "";
     while !is_last(peek(st) as char) {
-        rslt += str::from_byte(next(st));
+        rslt += str::unsafe_from_byte(next(st));
     }
     ret rslt;
 }
@@ -226,7 +226,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         while peek(st) as char != ']' {
             let name = "";
             while peek(st) as char != '=' {
-                name += str::from_byte(next(st));
+                name += str::unsafe_from_byte(next(st));
             }
             st.pos = st.pos + 1u;
             fields += [{ident: name, mt: parse_mt(st, conv)}];

branches/snap-stage3/src/comp/middle/debuginfo.rs

@@ -101,7 +101,7 @@ type metadata<T> = {node: ValueRef, data: T};
 
 type file_md = {path: str};
 type compile_unit_md = {path: str};
-type subprogram_md = {path: str};
+type subprogram_md = {id: ast::node_id};
 type local_var_md = {id: ast::node_id};
 type tydesc_md = {hash: uint};
 type block_md = {start: codemap::loc, end: codemap::loc};
@@ -225,39 +225,39 @@ fn line_from_span(cm: codemap::codemap, sp: span) -> uint {
 }
 
 fn create_block(cx: @block_ctxt, sp: span) -> @metadata<block_md> {
-    let cache = get_cache(bcx_ccx(cx));
+    //let cache = get_cache(bcx_ccx(cx));
     let start = codemap::lookup_char_pos(bcx_ccx(cx).sess.codemap,
                                          sp.lo);
     let fname = start.filename;
     let end = codemap::lookup_char_pos(bcx_ccx(cx).sess.codemap,
                                        sp.hi);
     let tg = LexicalBlockTag;
-    alt cached_metadata::<@metadata<block_md>>(
+    /*alt cached_metadata::<@metadata<block_md>>(
         cache, tg,
         {|md| start == md.data.start && end == md.data.end}) {
       option::some(md) { ret md; }
       option::none {}
-    }
+    }*/
 
     let parent = alt cx.parent {
       parent_none { create_function(cx.fcx, sp).node }
-      parent_some(bcx) { create_block(cx, sp).node }
+      parent_some(bcx) { create_block(bcx, sp).node }
     };
     let file_node = create_file(bcx_ccx(cx), fname);
-    let unique_id = alt cache.find(LexicalBlockTag) {
+    /*let unique_id = alt cache.find(LexicalBlockTag) {
       option::some(v) { vec::len(v) as int }
       option::none { 0 }
-    };
+    };*/
     let lldata = [lltag(tg),
                   parent,
                   lli32(start.line as int),
                   lli32(start.col as int),
-                  file_node.node,
-                  lli32(unique_id)
+                  file_node.node/*,
+                  lli32(unique_id)*/
                  ];
       let val = llmdnode(lldata);
       let mdval = @{node: val, data: {start: start, end: end}};
-      update_cache(cache, tg, block_metadata(mdval));
+      //update_cache(cache, tg, block_metadata(mdval));
       ret mdval;
 }
 
@@ -721,7 +721,7 @@ fn create_function(fcx: @fn_ctxt, sp: span) -> @metadata<subprogram_md> {
     #debug("~~");
     log(debug, fcx.id);
 
-    log(debug, codemap::span_to_str(sp, cx.sess.codemap));
+    //log(debug, codemap::span_to_str(sp, cx.sess.codemap));
 
     let (ident, ret_ty, id) = alt cx.ast_map.get(fcx.id) {
       ast_map::node_item(item) {
@@ -754,15 +754,14 @@ fn create_function(fcx: @fn_ctxt, sp: span) -> @metadata<subprogram_md> {
     log(debug, ident);
     log(debug, id);
 
-    let path = str::connect(fcx.lcx.path + [ident], "::");
-
-    let cache = get_cache(cx);
+    /*let cache = get_cache(cx);
     alt cached_metadata::<@metadata<subprogram_md>>(
-        cache, SubprogramTag, {|md| md.data.path == path &&
-                                    /*md.data.path == ??*/ true}) {
+        cache, SubprogramTag, {|md| md.data.id == id}) {
       option::some(md) { ret md; }
       option::none {}
-    }
+    }*/
+
+    let path = str::connect(fcx.lcx.path + [ident], "::");
 
     let loc = codemap::lookup_char_pos(cx.sess.codemap,
                                        sp.lo);
@@ -805,7 +804,7 @@ fn create_function(fcx: @fn_ctxt, sp: span) -> @metadata<subprogram_md> {
                       ];
     let val = llmdnode(fn_metadata);
     add_named_metadata(cx, "llvm.dbg.sp", val);
-    let mdval = @{node: val, data: {path: path}};
-    update_cache(cache, SubprogramTag, subprogram_metadata(mdval));
+    let mdval = @{node: val, data: {id: id}};
+    //update_cache(cache, SubprogramTag, subprogram_metadata(mdval));
     ret mdval;
 }

branches/snap-stage3/src/comp/middle/mut.rs

@@ -5,7 +5,7 @@ import syntax::visit;
 import syntax::ast_util;
 import driver::session::session;
 
-enum deref_t { unbox(bool), field, index, }
+enum deref_t { unbox, field, index, }
 
 type deref = @{mut: bool, kind: deref_t, outer_t: ty::t};
 
@@ -20,15 +20,15 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
         while true {
             alt ty::struct(tcx, t) {
               ty::ty_box(mt) {
-                ds += [@{mut: mt.mut == mut, kind: unbox(false), outer_t: t}];
+                ds += [@{mut: mt.mut == mut, kind: unbox, outer_t: t}];
                 t = mt.ty;
               }
               ty::ty_uniq(mt) {
-                ds += [@{mut: mt.mut == mut, kind: unbox(false), outer_t: t}];
+                ds += [@{mut: mt.mut == mut, kind: unbox, outer_t: t}];
                 t = mt.ty;
               }
               ty::ty_res(_, inner, tps) {
-                ds += [@{mut: false, kind: unbox(false), outer_t: t}];
+                ds += [@{mut: false, kind: unbox, outer_t: t}];
                 t = ty::substitute_type_params(tcx, tps, inner);
               }
               ty::ty_enum(did, tps) {
@@ -37,7 +37,7 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
                        vec::len(variants[0].args) != 1u {
                     break;
                 }
-                ds += [@{mut: false, kind: unbox(false), outer_t: t}];
+                ds += [@{mut: false, kind: unbox, outer_t: t}];
                 t = ty::substitute_type_params(tcx, tps, variants[0].args[0]);
               }
               _ { break; }
@@ -85,16 +85,15 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
           expr_unary(op, base) {
             if op == deref {
                 let base_t = ty::expr_ty(tcx, base);
-                let is_mut = false, ptr = false;
+                let is_mut = false;
                 alt ty::struct(tcx, base_t) {
                   ty::ty_box(mt) { is_mut = mt.mut == mut; }
                   ty::ty_uniq(mt) { is_mut = mt.mut == mut; }
                   ty::ty_res(_, _, _) { }
                   ty::ty_enum(_, _) { }
-                  ty::ty_ptr(mt) { is_mut = mt.mut == mut; ptr = true; }
+                  ty::ty_ptr(mt) { is_mut = mt.mut == mut; }
                 }
-                ds += [@{mut: is_mut, kind: unbox(ptr && is_mut),
-                         outer_t: base_t}];
+                ds += [@{mut: is_mut, kind: unbox, outer_t: base_t}];
                 ex = base;
             } else { break; }
           }
@@ -188,7 +187,7 @@ fn check_lval(cx: @ctx, dest: @expr, msg: msg) {
         } else if !root.ds[0].mut {
             let name =
                 alt root.ds[0].kind {
-                  mut::unbox(_) { "immutable box" }
+                  mut::unbox { "immutable box" }
                   mut::field { "immutable field" }
                   mut::index { "immutable vec content" }
                 };
@@ -213,8 +212,7 @@ fn check_move_rhs(cx: @ctx, src: @expr) {
         let root = expr_root(cx.tcx, src, false);
 
         // Not a path and no-derefs means this is a temporary.
-        if vec::len(*root.ds) != 0u &&
-           root.ds[vec::len(*root.ds) - 1u].kind != unbox(true) {
+        if vec::len(*root.ds) != 0u {
             cx.tcx.sess.span_err(src.span, "moving out of a data structure");
         }
       }

branches/snap-stage3/src/comp/middle/trans/base.rs

@@ -268,7 +268,7 @@ fn sanitize(s: str) -> str {
                            c != ' ' as u8 && c != '\t' as u8 && c != ';' as u8
                        {
                         let v = [c];
-                        result += str::from_bytes(v);
+                        result += str::unsafe_from_bytes(v);
                     }
                 }
             }
@@ -5412,7 +5412,7 @@ fn fill_crate_map(ccx: @crate_ctxt, map: ValueRef) {
 
 fn write_metadata(cx: @crate_ctxt, crate: @ast::crate) {
     if !cx.sess.building_library { ret; }
-    let llmeta = C_bytes(metadata::encoder::encode_metadata(cx, crate));
+    let llmeta = C_postr(metadata::encoder::encode_metadata(cx, crate));
     let llconst = C_struct([llmeta]);
     let llglobal = str::as_buf("rust_metadata", {|buf|
         llvm::LLVMAddGlobal(cx.llmod, val_ty(llconst), buf)

branches/snap-stage3/src/comp/middle/ty.rs

@@ -172,7 +172,6 @@ export type_is_str;
 export type_is_unique;
 export type_is_enum;
 export type_is_c_like_enum;
-export type_structurally_contains;
 export type_structurally_contains_uniques;
 export type_autoderef;
 export type_param;
@@ -2421,8 +2420,7 @@ mod unify {
     fn fixup_vars(tcx: ty_ctxt, sp: option::t<span>, vb: @var_bindings,
                   typ: t) -> fixup_result {
         fn subst_vars(tcx: ty_ctxt, sp: option::t<span>, vb: @var_bindings,
-                      unresolved: @mutable option::t<int>,
-                      vars_seen: std::list::list<int>, vid: int) -> t {
+                      unresolved: @mutable option::t<int>, vid: int) -> t {
             // Should really return a fixup_result instead of a t, but fold_ty
             // doesn't allow returning anything but a t.
             if vid as uint >= ufind::set_count(vb.sets) {
@@ -2433,28 +2431,21 @@ mod unify {
             alt smallintmap::find::<t>(vb.types, root_id) {
               none { *unresolved = some(vid); ret ty::mk_var(tcx, vid); }
               some(rt) {
-                let give_up = false;
-                std::list::iter(vars_seen) {|v|
-                    if v == vid {
-                        give_up = true;
-                        option::may(sp) {|sp|
-                            tcx.sess.span_fatal(
-                                sp, "can not instantiate infinite type");
-                        }
-                    }
+                if occurs_check_fails(tcx, sp, vid, rt) {
+                    // Return the type unchanged, so we can error out
+                    // downstream
+                    ret rt;
                 }
-                // Return the type unchanged, so we can error out
-                // downstream
-                if give_up { ret rt; }
-                ret fold_ty(tcx, fm_var(bind subst_vars(
-                    tcx, sp, vb, unresolved, std::list::cons(vid, @vars_seen),
-                    _)), rt);
+                ret fold_ty(tcx,
+                            fm_var(bind subst_vars(tcx, sp, vb, unresolved,
+                                                   _)), rt);
               }
             }
         }
         let unresolved = @mutable none::<int>;
-        let rty = fold_ty(tcx, fm_var(bind subst_vars(
-            tcx, sp, vb, unresolved, std::list::nil, _)), typ);
+        let rty =
+            fold_ty(tcx, fm_var(bind subst_vars(tcx, sp, vb, unresolved, _)),
+                    typ);
         let ur = *unresolved;
         alt ur {
           none { ret fix_ok(rty); }