---

yaml
---
r: 8105
b: refs/heads/snap-stage3
c: 8673c4f
h: refs/heads/master
i:
  8103: ac635a0
v: v3

Author: marijnh

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6ed8d037841aab1b2855525bf141c5c1c4de4910
+refs/heads/snap-stage3: 8673c4f195be8377f8e0d83929f9a16bb99092a0
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

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

@@ -113,7 +113,7 @@ fn doc_type(doc: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ty::t {
 fn item_type(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ty::t {
     let t = doc_type(item, tcx, cdata);
     if family_names_type(item_family(item)) {
-        ty::mk_named(tcx, t, @item_name(item))
+        ty::mk_named(tcx, t, item_name(item))
     } else { t }
 }
 
@@ -247,7 +247,7 @@ fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
         let ctor_ty = item_type(item, tcx, cdata);
         let name = item_name(item);
         let arg_tys: [ty::t] = [];
-        alt ty::struct(tcx, ctor_ty) {
+        alt ty::get(ctor_ty).struct {
           ty::ty_fn(f) {
             for a: ty::arg in f.inputs { arg_tys += [a.ty]; }
           }
@@ -302,7 +302,7 @@ fn get_iface_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
         let bounds = item_ty_param_bounds(mth, tcx, cdata);
         let name = item_name(mth);
         let ty = doc_type(mth, tcx, cdata);
-        let fty = alt ty::struct(tcx, ty) { ty::ty_fn(f) { f }
+        let fty = alt ty::get(ty).struct { ty::ty_fn(f) { f }
           _ { tcx.sess.bug("get_iface_methods: id has non-function type");
         } };
         result += [{ident: name, tps: bounds, fty: fty}];

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

@@ -353,7 +353,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_def_id(ebml_w, local_def(ctor_id));
         encode_family(ebml_w, 'y' as u8);
         encode_type_param_bounds(ebml_w, ecx, tps);
-        encode_type(ecx, ebml_w, ty::ty_fn_ret(tcx, fn_ty));
+        encode_type(ecx, ebml_w, ty::ty_fn_ret(fn_ty));
         encode_name(ebml_w, item.ident);
         encode_symbol(ecx, ebml_w, item.id);
         ebml::end_tag(ebml_w);

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

@@ -299,7 +299,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         while peek(st) as char != '"' { str::push_byte(name, next(st)); }
         st.pos = st.pos + 1u;
         let inner = parse_ty(st, conv);
-        ty::mk_named(st.tcx, inner, @name)
+        ty::mk_named(st.tcx, inner, name)
       }
       c { #error("unexpected char in type string: %c", c); fail;}
     }

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

@@ -42,8 +42,7 @@ fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) {
           some(s) { *s }
           none {
             let buf = io::mk_mem_buffer();
-            enc_sty(io::mem_buffer_writer(buf), cx,
-                    ty::struct_raw(cx.tcx, t));
+            enc_sty(io::mem_buffer_writer(buf), cx, ty::get(t).struct);
             cx.tcx.short_names_cache.insert(t, @io::mem_buffer_str(buf));
             io::mem_buffer_str(buf)
           }
@@ -55,7 +54,15 @@ fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) {
           some(a) { w.write_str(*a.s); ret; }
           none {
             let pos = w.tell();
-            enc_sty(w, cx, ty::struct_raw(cx.tcx, t));
+            alt ty::type_name(t) {
+              some(n) {
+                w.write_char('"');
+                w.write_str(n);
+                w.write_char('"');
+              }
+              _ {}
+            }
+            enc_sty(w, cx, ty::get(t).struct);
             let end = w.tell();
             let len = end - pos;
             fn estimate_sz(u: uint) -> uint {
@@ -185,14 +192,6 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
         for tc: @ty::type_constr in cs { enc_ty_constr(w, cx, tc); }
         w.write_char(']');
       }
-      ty::ty_named(t, name) {
-        if cx.abbrevs != ac_no_abbrevs {
-            w.write_char('"');
-            w.write_str(*name);
-            w.write_char('"');
-        }
-        enc_ty(w, cx, t);
-      }
     }
 }
 fn enc_proto(w: io::writer, proto: proto) {

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

@@ -80,7 +80,7 @@ fn visit_fn(cx: @ctx, _fk: visit::fn_kind, decl: ast::fn_decl,
             id: ast::node_id, sc: scope, v: vt<scope>) {
     visit::visit_fn_decl(decl, sc, v);
     let fty = ty::node_id_to_type(cx.tcx, id);
-    let args = ty::ty_fn_args(cx.tcx, fty);
+    let args = ty::ty_fn_args(fty);
     for arg in args {
         alt ty::resolved_mode(cx.tcx, arg.mode) {
           ast::by_val if ty::type_has_dynamic_size(cx.tcx, arg.ty) {
@@ -92,7 +92,7 @@ fn visit_fn(cx: @ctx, _fk: visit::fn_kind, decl: ast::fn_decl,
 
     // Blocks need to obey any restrictions from the enclosing scope, and may
     // be called multiple times.
-    let proto = ty::ty_fn_proto(cx.tcx, fty);
+    let proto = ty::ty_fn_proto(fty);
     alt proto {
       ast::proto_block | ast::proto_any {
         check_loop(*cx, sc) {|| v.visit_block(body, sc, v);}
@@ -221,7 +221,7 @@ fn cant_copy(cx: ctx, b: binding) -> bool {
 fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr])
     -> [binding] {
     let fty = ty::expr_ty(cx.tcx, f);
-    let arg_ts = ty::ty_fn_args(cx.tcx, fty);
+    let arg_ts = ty::ty_fn_args(fty);
     let mut_roots: [{arg: uint, node: node_id}] = [];
     let bindings = [];
     let i = 0u;
@@ -371,7 +371,7 @@ fn check_for(cx: ctx, local: @ast::local, seq: @ast::expr, blk: ast::blk,
     // If this is a mutable vector, don't allow it to be touched.
     let seq_t = ty::expr_ty(cx.tcx, seq);
     let cur_mut = root.mut;
-    alt ty::struct(cx.tcx, seq_t) {
+    alt ty::get(seq_t).struct {
       ty::ty_vec(mt) {
         if mt.mut != ast::imm {
             cur_mut = some(contains(seq_t));
@@ -510,7 +510,7 @@ fn ty_can_unsafely_include(cx: ctx, needle: unsafe_ty, haystack: ty::t,
           contains(ty) { ty == haystack }
           mut_contains(ty) { mut && ty == haystack }
         } { ret true; }
-        alt ty::struct(tcx, haystack) {
+        alt ty::get(haystack).struct {
           ty::ty_enum(_, ts) {
             for t: ty::t in ts {
                 if helper(tcx, needle, t, mut) { ret true; }
@@ -565,7 +565,7 @@ fn local_id_of_node(cx: ctx, id: node_id) -> uint {
 // implicit copy.
 fn copy_is_expensive(tcx: ty::ctxt, ty: ty::t) -> bool {
     fn score_ty(tcx: ty::ctxt, ty: ty::t) -> uint {
-        ret alt ty::struct(tcx, ty) {
+        ret alt ty::get(ty).struct {
           ty::ty_nil | ty::ty_bot | ty::ty_bool | ty::ty_int(_) |
           ty::ty_uint(_) | ty::ty_float(_) | ty::ty_type |
           ty::ty_ptr(_) { 1u }
@@ -623,7 +623,7 @@ fn pattern_roots(tcx: ty::ctxt, mut: option<unsafe_ty>, pat: @ast::pat)
           }
           ast::pat_box(p) {
             let ty = ty::node_id_to_type(tcx, pat.id);
-            let m = alt ty::struct(tcx, ty) {
+            let m = alt ty::get(ty).struct {
               ty::ty_box(mt) { mt.mut != ast::imm }
               _ { tcx.sess.span_bug(pat.span, "box pat has non-box type"); }
             },
@@ -632,7 +632,7 @@ fn pattern_roots(tcx: ty::ctxt, mut: option<unsafe_ty>, pat: @ast::pat)
           }
           ast::pat_uniq(p) {
             let ty = ty::node_id_to_type(tcx, pat.id);
-            let m = alt ty::struct(tcx, ty) {
+            let m = alt ty::get(ty).struct {
               ty::ty_uniq(mt) { mt.mut != ast::imm }
               _ { tcx.sess.span_bug(pat.span, "uniq pat has non-uniq type"); }
             },

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

@@ -13,7 +13,7 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) {
 
 fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
     if !cx.allow_block {
-        alt ty::struct(cx.tcx, ty::expr_ty(cx.tcx, ex)) {
+        alt ty::get(ty::expr_ty(cx.tcx, ex)).struct {
           ty::ty_fn({proto: p, _}) if is_blockish(p) {
             cx.tcx.sess.span_err(ex.span, "expressions with block type \
                 can only appear in callee or (by-ref) argument position");
@@ -27,7 +27,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
         cx.allow_block = true;
         v.visit_expr(f, cx, v);
         let i = 0u;
-        for arg_t in ty::ty_fn_args(cx.tcx, ty::expr_ty(cx.tcx, f)) {
+        for arg_t in ty::ty_fn_args(ty::expr_ty(cx.tcx, f)) {
             cx.allow_block = (ty::arg_mode(cx.tcx, arg_t) == by_ref);
             v.visit_expr(args[i], cx, v);
             i += 1u;

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

@@ -73,7 +73,7 @@ fn check_exhaustive(tcx: ty::ctxt, sp:span, scrut_ty:ty::t, pats:[@pat]) {
     /* Otherwise, get the list of variants and make sure each one is
      represented. Then recurse on the columns. */
 
-    let ty_def_id = alt ty::struct(tcx, scrut_ty) {
+    let ty_def_id = alt ty::get(scrut_ty).struct {
             ty_enum(id, _) { id }
             _ { ret; } };
 

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

@@ -280,7 +280,7 @@ fn create_basic_type(cx: @crate_ctxt, t: ty::t, ty: @ast::ty)
     let cache = get_cache(cx);
     let tg = BasicTypeDescriptorTag;
     alt cached_metadata::<@metadata<tydesc_md>>(
-        cache, tg, {|md| t == md.data.hash}) {
+        cache, tg, {|md| ty::type_id(t) == md.data.hash}) {
       option::some(md) { ret md; }
       option::none {}
     }
@@ -325,7 +325,7 @@ fn create_basic_type(cx: @crate_ctxt, t: ty::t, ty: @ast::ty)
                   lli32(0), //XXX flags?
                   lli32(encoding)];
     let llnode = llmdnode(lldata);
-    let mdval = @{node: llnode, data: {hash: t}};
+    let mdval = @{node: llnode, data: {hash: ty::type_id(t)}};
     update_cache(cache, tg, tydesc_metadata(mdval));
     add_named_metadata(cx, "llvm.dbg.ty", llnode);
     ret mdval;
@@ -347,7 +347,7 @@ fn create_pointer_type(cx: @crate_ctxt, t: ty::t, span: span,
     //let cu_node = create_compile_unit(cx, fname);
     let llnode = create_derived_type(tg, file_node.node, "", 0, size * 8,
                                      align * 8, 0, pointee.node);
-    let mdval = @{node: llnode, data: {hash: t}};
+    let mdval = @{node: llnode, data: {hash: ty::type_id(t)}};
     //update_cache(cache, tg, tydesc_metadata(mdval));
     add_named_metadata(cx, "llvm.dbg.ty", llnode);
     ret mdval;
@@ -420,7 +420,7 @@ fn create_record(cx: @crate_ctxt, t: ty::t, fields: [ast::ty_field],
                    line_from_span(cx.sess.codemap, field.span) as int,
                    size as int, align as int, ty_md.node);
     }
-    let mdval = @{node: finish_structure(scx), data:{hash: t}};
+    let mdval = @{node: finish_structure(scx), data:{hash: ty::type_id(t)}};
     ret mdval;
 }
 
@@ -448,7 +448,7 @@ fn create_boxed_type(cx: @crate_ctxt, outer: ty::t, _inner: ty::t,
                8, //XXX just a guess
                boxed.node);
     let llnode = finish_structure(scx);
-    let mdval = @{node: llnode, data: {hash: outer}};
+    let mdval = @{node: llnode, data: {hash: ty::type_id(outer)}};
     //update_cache(cache, tg, tydesc_metadata(mdval));
     add_named_metadata(cx, "llvm.dbg.ty", llnode);
     ret mdval;
@@ -507,7 +507,7 @@ fn create_vec(cx: @crate_ctxt, vec_t: ty::t, elem_t: ty::t,
     add_member(scx, "data", 0, 0, // clang says the size should be 0
                sys::align_of::<u8>() as int, data_ptr);
     let llnode = finish_structure(scx);
-    ret @{node: llnode, data: {hash: vec_t}};
+    ret @{node: llnode, data: {hash: ty::type_id(vec_t)}};
 }
 
 fn member_size_and_align(ty: @ast::ty) -> (int, int) {
@@ -561,7 +561,7 @@ fn create_ty(cx: @crate_ctxt, t: ty::t, ty: @ast::ty)
     }*/
 
     fn t_to_ty(cx: @crate_ctxt, t: ty::t, span: span) -> @ast::ty {
-        let ty = alt ty::struct(ccx_tcx(cx), t) {
+        let ty = alt ty::get(t).struct {
           ty::ty_nil { ast::ty_nil }
           ty::ty_bot { ast::ty_bot }
           ty::ty_bool { ast::ty_bool }
@@ -593,7 +593,7 @@ fn create_ty(cx: @crate_ctxt, t: ty::t, ty: @ast::ty)
 
     alt ty.node {
       ast::ty_box(mt) {
-        let inner_t = alt ty::struct(ccx_tcx(cx), t) {
+        let inner_t = alt ty::get(t).struct {
           ty::ty_box(boxed) { boxed.ty }
           _ { cx.tcx.sess.span_bug(ty.span, "t_to_ty was incoherent"); }
         };
@@ -603,7 +603,7 @@ fn create_ty(cx: @crate_ctxt, t: ty::t, ty: @ast::ty)
       }
 
       ast::ty_uniq(mt) {
-        let inner_t = alt ty::struct(ccx_tcx(cx), t) {
+        let inner_t = alt ty::get(t).struct {
           ty::ty_uniq(boxed) { boxed.ty }
           // Hoping we'll have a way to eliminate this check soon.
           _ { cx.tcx.sess.span_bug(ty.span, "t_to_ty was incoherent"); }

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

@@ -31,7 +31,7 @@ fn fn_usage_expr(expr: @ast::expr,
         }
         if !ctx.generic_bare_fn_legal
             && ty::expr_has_ty_params(ctx.tcx, expr) {
-            alt ty::struct(ctx.tcx, ty::expr_ty(ctx.tcx, expr)) {
+            alt ty::get(ty::expr_ty(ctx.tcx, expr)).struct {
               ty::ty_fn({proto: ast::proto_bare, _}) {
                 ctx.tcx.sess.span_fatal(
                     expr.span,

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

@@ -60,7 +60,7 @@ fn check_crate(tcx: ty::ctxt, method_map: typeck::method_map,
 fn with_appropriate_checker(cx: ctx, id: node_id,
                             b: fn(fn@(ctx, ty::t, sp: span))) {
     let fty = ty::node_id_to_type(cx.tcx, id);
-    alt ty::ty_fn_proto(cx.tcx, fty) {
+    alt ty::ty_fn_proto(fty) {
       proto_uniq { b(check_send); }
       proto_box { b(check_copy); }
       proto_bare { b(check_none); }
@@ -142,9 +142,10 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
           some(ex) {
             // All noncopyable fields must be overridden
             let t = ty::expr_ty(cx.tcx, ex);
-            let ty_fields = alt ty::struct(cx.tcx, t) { ty::ty_rec(f) { f }
-              _ { cx.tcx.sess.span_bug(ex.span,
-                     "Bad expr type in record"); } };
+            let ty_fields = alt ty::get(t).struct {
+              ty::ty_rec(f) { f }
+              _ { cx.tcx.sess.span_bug(ex.span, "Bad expr type in record"); }
+            };
             for tf in ty_fields {
                 if !vec::any(fields, {|f| f.node.ident == tf.ident}) &&
                     !ty::kind_can_be_copied(ty::type_kind(cx.tcx, tf.mt.ty)) {
@@ -164,7 +165,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
       }
       expr_call(f, args, _) {
         let i = 0u;
-        for arg_t in ty::ty_fn_args(cx.tcx, ty::expr_ty(cx.tcx, f)) {
+        for arg_t in ty::ty_fn_args(ty::expr_ty(cx.tcx, f)) {
             alt ty::arg_mode(cx.tcx, arg_t) {
               by_copy { maybe_copy(cx, args[i]); }
               by_ref | by_val | by_mut_ref | by_move { }
@@ -242,7 +243,7 @@ fn check_copy_ex(cx: ctx, ex: @expr, _warn: bool) {
         check_copy(cx, ty, ex.span);
         // FIXME turn this on again once vector types are no longer unique.
         // Right now, it is too annoying to be useful.
-        /* if warn && ty::type_is_unique(cx.tcx, ty) {
+        /* if warn && ty::type_is_unique(ty) {
             cx.tcx.sess.span_warn(ex.span, "copying a unique value");
         }*/
     }

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

@@ -65,7 +65,7 @@ fn find_last_uses(c: @crate, def_map: resolve::def_map,
 }
 
 fn ex_is_blockish(cx: ctx, id: node_id) -> bool {
-    alt ty::struct(cx.tcx, ty::node_id_to_type(cx.tcx, id)) {
+    alt ty::get(ty::node_id_to_type(cx.tcx, id)).struct {
       ty::ty_fn({proto: p, _}) if is_blockish(p) { true }
       _ { false }
     }
@@ -147,7 +147,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
       expr_call(f, args, _) {
         v.visit_expr(f, cx, v);
         let i = 0u, fns = [];
-        let arg_ts = ty::ty_fn_args(cx.tcx, ty::expr_ty(cx.tcx, f));
+        let arg_ts = ty::ty_fn_args(ty::expr_ty(cx.tcx, f));
         for arg in args {
             alt arg.node {
               expr_fn(p, _, _, _) if is_blockish(p) {
@@ -175,7 +175,7 @@ fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
             sp: span, id: node_id,
             cx: ctx, v: visit::vt<ctx>) {
     let fty = ty::node_id_to_type(cx.tcx, id);
-    let proto = ty::ty_fn_proto(cx.tcx, fty);
+    let proto = ty::ty_fn_proto(fty);
     alt proto {
       proto_any | proto_block {
         visit_block(func, cx, {||