---

yaml
---
r: 6951
b: refs/heads/master
c: 38e796b
h: refs/heads/master
i:
  6949: cfe5be2
  6947: bfd50bd
  6943: 459982d
v: v3

Author: erickt

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 9236fdf39f2cf38b9642768214c39ea1c9543628
+refs/heads/master: 38e796b943bddcbc3f4dfb664632b778451751f2

trunk/src/comp/metadata/common.rs

@@ -22,7 +22,7 @@ const tag_items_data_item: uint = 0x09u;
 
 const tag_items_data_item_family: uint = 0x0au;
 
-const tag_items_data_item_ty_param_bounds: uint = 0x0bu;
+const tag_items_data_item_ty_param_kinds: uint = 0x0bu;
 
 const tag_items_data_item_type: uint = 0x0cu;
 

trunk/src/comp/metadata/csearch.rs

@@ -86,7 +86,7 @@ fn get_impl_methods(cstore: cstore::cstore, def: ast::def_id)
     decoder::lookup_impl_methods(cdata, def.node, def.crate)
 }
 
-fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty {
+fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_kinds_and_ty {
     let cstore = tcx.sess.get_cstore();
     let cnum = def.crate;
     let cdata = cstore::get_crate_data(cstore, cnum).data;

trunk/src/comp/metadata/decoder.rs

@@ -14,6 +14,7 @@ export get_symbol;
 export get_tag_variants;
 export get_type;
 export get_type_param_count;
+export get_type_param_kinds;
 export lookup_def;
 export lookup_item_name;
 export resolve_path;
@@ -89,22 +90,21 @@ fn variant_tag_id(d: ebml::doc) -> ast::def_id {
     ret parse_def_id(ebml::doc_data(tagdoc));
 }
 
-fn parse_external_def_id(this_cnum: ast::crate_num,
-                         extres: external_resolver, s: str) ->
-    ast::def_id {
-    let buf = str::bytes(s);
-    let external_def_id = parse_def_id(buf);
-
-
-    // This item was defined in the crate we're searching if it's has the
-    // local crate number, otherwise we need to search a different crate
-    if external_def_id.crate == ast::local_crate {
-        ret {crate: this_cnum, node: external_def_id.node};
-    } else { ret extres(external_def_id); }
-}
-
 fn item_type(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
              extres: external_resolver) -> ty::t {
+    fn parse_external_def_id(this_cnum: ast::crate_num,
+                             extres: external_resolver, s: str) ->
+       ast::def_id {
+        let buf = str::bytes(s);
+        let external_def_id = parse_def_id(buf);
+
+
+        // This item was defined in the crate we're searching if it's has the
+        // local crate number, otherwise we need to search a different crate
+        if external_def_id.crate == ast::local_crate {
+            ret {crate: this_cnum, node: external_def_id.node};
+        } else { ret extres(external_def_id); }
+    }
     let tp = ebml::get_doc(item, tag_items_data_item_type);
     let def_parser = bind parse_external_def_id(this_cnum, extres, _);
     let t = parse_ty_data(item.data, this_cnum, tp.start, tp.end - tp.start,
@@ -115,24 +115,32 @@ fn item_type(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
     t
 }
 
-fn item_ty_param_bounds(item: ebml::doc, this_cnum: ast::crate_num,
-                        tcx: ty::ctxt, extres: external_resolver)
-    -> [@[ty::param_bound]] {
-    let bounds = [];
-    let def_parser = bind parse_external_def_id(this_cnum, extres, _);
-    ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) {|p|
-        bounds += [tydecode::parse_bounds_data(@ebml::doc_data(p), this_cnum,
-                                               def_parser, tcx)];
-    }
-    bounds
+fn item_ty_param_kinds(item: ebml::doc) -> [ast::kind] {
+    let ks: [ast::kind] = [];
+    let tp = tag_items_data_item_ty_param_kinds;
+    ebml::tagged_docs(item, tp) {|p|
+        let dat: [u8] = ebml::doc_data(p);
+        let vi = ebml::vint_at(dat, 0u);
+        let i = 0u;
+        while i < vi.val {
+            let k =
+                alt dat[vi.next + i] as char {
+                  's' { ast::kind_sendable }
+                  'c' { ast::kind_copyable }
+                  'a' { ast::kind_noncopyable }
+                };
+            ks += [k];
+            i += 1u;
+        }
+    };
+    ret ks;
 }
 
 fn item_ty_param_count(item: ebml::doc) -> uint {
     let n = 0u;
-    ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) {|p|
-        for byte in ebml::doc_data(p) {
-            if byte as char == '.' { n += 1u; }
-        }
+    let tp = tag_items_data_item_ty_param_kinds;
+    ebml::tagged_docs(item, tp) {|p|
+        n += ebml::vint_at(ebml::doc_data(p), 0u).val;
     }
     n
 }
@@ -205,21 +213,28 @@ fn lookup_def(cnum: ast::crate_num, data: @[u8], did_: ast::def_id) ->
 }
 
 fn get_type(data: @[u8], def: ast::def_id, tcx: ty::ctxt,
-            extres: external_resolver) -> ty::ty_param_bounds_and_ty {
+            extres: external_resolver) -> ty::ty_param_kinds_and_ty {
     let this_cnum = def.crate;
     let node_id = def.node;
     let item = lookup_item(node_id, data);
     let t = item_type(item, this_cnum, tcx, extres);
-    let tp_bounds = if family_has_type_params(item_family(item)) {
-        item_ty_param_bounds(item, this_cnum, tcx, extres)
-    } else { [] };
-    ret {bounds: tp_bounds, ty: t};
+    let tp_kinds: [ast::kind];
+    let fam_ch = item_family(item);
+    let has_ty_params = family_has_type_params(fam_ch);
+    if has_ty_params {
+        tp_kinds = item_ty_param_kinds(item);
+    } else { tp_kinds = []; }
+    ret {kinds: tp_kinds, ty: t};
 }
 
 fn get_type_param_count(data: @[u8], id: ast::node_id) -> uint {
     item_ty_param_count(lookup_item(id, data))
 }
 
+fn get_type_param_kinds(data: @[u8], id: ast::node_id) -> [ast::kind] {
+    ret item_ty_param_kinds(lookup_item(id, data));
+}
+
 fn get_symbol(data: @[u8], id: ast::node_id) -> str {
     ret item_symbol(lookup_item(id, data));
 }

trunk/src/comp/metadata/encoder.rs

@@ -183,17 +183,18 @@ fn encode_family(ebml_w: ebml::writer, c: u8) {
 
 fn def_to_str(did: def_id) -> str { ret #fmt["%d:%d", did.crate, did.node]; }
 
-fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt,
-                            params: [ty_param]) {
-    let ty_str_ctxt = @{ds: def_to_str,
-                        tcx: ecx.ccx.tcx,
-                        abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
-    for param in params {
-        ebml::start_tag(ebml_w, tag_items_data_item_ty_param_bounds);
-        let bs = ecx.ccx.tcx.ty_param_bounds.get(local_def(param.id));
-        tyencode::enc_bounds(io::new_writer(ebml_w.writer), ty_str_ctxt, bs);
-        ebml::end_tag(ebml_w);
+fn encode_type_param_kinds(ebml_w: ebml::writer, tps: [ty_param]) {
+    ebml::start_tag(ebml_w, tag_items_data_item_ty_param_kinds);
+    ebml::write_vint(ebml_w.writer, vec::len::<ty_param>(tps));
+    for tp: ty_param in tps {
+        let c = alt ast_util::ty_param_kind(tp) {
+          kind_sendable. { 's' }
+          kind_copyable. { 'c' }
+          kind_noncopyable. { 'a' }
+        };
+        ebml_w.writer.write([c as u8]);
     }
+    ebml::end_tag(ebml_w);
 }
 
 fn encode_variant_id(ebml_w: ebml::writer, vid: def_id) {
@@ -204,8 +205,9 @@ fn encode_variant_id(ebml_w: ebml::writer, vid: def_id) {
 
 fn encode_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
     ebml::start_tag(ebml_w, tag_items_data_item_type);
+    let f = def_to_str;
     let ty_str_ctxt =
-        @{ds: def_to_str,
+        @{ds: f,
           tcx: ecx.ccx.tcx,
           abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     tyencode::enc_ty(io::new_writer(ebml_w.writer), ty_str_ctxt, typ);
@@ -245,7 +247,7 @@ fn encode_tag_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
             encode_symbol(ecx, ebml_w, variant.node.id);
         }
         encode_discriminant(ecx, ebml_w, variant.node.id);
-        encode_type_param_bounds(ebml_w, ecx, ty_params);
+        encode_type_param_kinds(ebml_w, ty_params);
         ebml::end_tag(ebml_w);
     }
 }
@@ -291,7 +293,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
                         pure_fn. { 'p' }
                         impure_fn. { 'f' }
                       } as u8);
-        encode_type_param_bounds(ebml_w, ecx, tps);
+        encode_type_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, item.id));
         encode_symbol(ecx, ebml_w, item.id);
         ebml::end_tag(ebml_w);
@@ -310,7 +312,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'y' as u8);
-        encode_type_param_bounds(ebml_w, ecx, tps);
+        encode_type_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, item.id));
         encode_name(ebml_w, item.ident);
         ebml::end_tag(ebml_w);
@@ -319,7 +321,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 't' as u8);
-        encode_type_param_bounds(ebml_w, ecx, tps);
+        encode_type_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, item.id));
         encode_name(ebml_w, item.ident);
         for v: variant in variants {
@@ -334,7 +336,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml::start_tag(ebml_w, tag_items_data_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_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, ty::ty_fn_ret(ecx.ccx.tcx, fn_ty));
         encode_name(ebml_w, item.ident);
         encode_symbol(ecx, ebml_w, item.id);
@@ -344,7 +346,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(ctor_id));
         encode_family(ebml_w, 'f' as u8);
-        encode_type_param_bounds(ebml_w, ecx, tps);
+        encode_type_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, fn_ty);
         encode_symbol(ecx, ebml_w, ctor_id);
         ebml::end_tag(ebml_w);
@@ -355,7 +357,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'y' as u8);
-        encode_type_param_bounds(ebml_w, ecx, tps);
+        encode_type_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, ty::ty_fn_ret(ecx.ccx.tcx, fn_ty));
         encode_name(ebml_w, item.ident);
         ebml::end_tag(ebml_w);
@@ -364,7 +366,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(ctor_id));
         encode_family(ebml_w, 'f' as u8);
-        encode_type_param_bounds(ebml_w, ecx, tps);
+        encode_type_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, fn_ty);
         encode_symbol(ecx, ebml_w, ctor_id);
         ebml::end_tag(ebml_w);
@@ -373,7 +375,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'i' as u8);
-        encode_type_param_bounds(ebml_w, ecx, tps);
+        encode_type_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, item.id));
         encode_name(ebml_w, item.ident);
         for m in methods {
@@ -388,7 +390,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
             ebml::start_tag(ebml_w, tag_items_data_item);
             encode_def_id(ebml_w, local_def(m.id));
             encode_family(ebml_w, 'f' as u8);
-            encode_type_param_bounds(ebml_w, ecx, tps + m.tps);
+            encode_type_param_kinds(ebml_w, tps + m.tps);
             encode_type(ecx, ebml_w,
                         node_id_to_monotype(ecx.ccx.tcx, m.id));
             encode_name(ebml_w, m.ident);
@@ -419,7 +421,7 @@ fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
             } as u8;
         encode_def_id(ebml_w, local_def(nitem.id));
         encode_family(ebml_w, letter);
-        encode_type_param_bounds(ebml_w, ecx, tps);
+        encode_type_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, nitem.id));
         encode_symbol(ecx, ebml_w, nitem.id);
       }

trunk/src/comp/metadata/tydecode.rs

@@ -10,7 +10,6 @@ import middle::ty;
 
 export parse_def_id;
 export parse_ty_data;
-export parse_bounds_data;
 
 // Compact string representation for ty::t values. API ty_str &
 // parse_from_str. Extra parameters are for converting to/from def_ids in the
@@ -22,9 +21,7 @@ type str_def = fn@(str) -> ast::def_id;
 type pstate =
     {data: @[u8], crate: int, mutable pos: uint, len: uint, tcx: ty::ctxt};
 
-fn peek(st: @pstate) -> u8 {
-    if st.pos < vec::len(*st.data) { st.data[st.pos] } else { 0u8 }
-}
+fn peek(st: @pstate) -> u8 { ret st.data[st.pos]; }
 
 fn next(st: @pstate) -> u8 {
     let ch = st.data[st.pos];
@@ -51,7 +48,8 @@ fn parse_ty_data(data: @[u8], crate_num: int, pos: uint, len: uint,
                  sd: str_def, tcx: ty::ctxt) -> ty::t {
     let st =
         @{data: data, crate: crate_num, mutable pos: pos, len: len, tcx: tcx};
-    parse_ty(st, sd)
+    let result = parse_ty(st, sd);
+    ret result;
 }
 
 fn parse_ret_ty(st: @pstate, sd: str_def) -> (ast::ret_style, ty::t) {
@@ -203,8 +201,18 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
         ret ty::mk_tag(st.tcx, def, params);
       }
       'p' {
-        let bounds = parse_bounds(st, sd);
-        ret ty::mk_param(st.tcx, parse_int(st) as uint, bounds);
+        let k =
+            alt next(st) as char {
+              's' { kind_sendable }
+              'c' { kind_copyable }
+              'a' { kind_noncopyable }
+              c {
+                #error("unexpected char in encoded type param: ");
+                log(error, c);
+                fail
+              }
+            };
+        ret ty::mk_param(st.tcx, parse_int(st) as uint, k);
       }
       '@' { ret ty::mk_box(st.tcx, parse_mt(st, sd)); }
       '~' { ret ty::mk_uniq(st.tcx, parse_mt(st, sd)); }
@@ -392,26 +400,6 @@ fn parse_def_id(buf: [u8]) -> ast::def_id {
     ret {crate: crate_num, node: def_num};
 }
 
-fn parse_bounds_data(data: @[u8], crate_num: int, sd: str_def, tcx: ty::ctxt)
-    -> @[ty::param_bound] {
-    let st = @{data: data, crate: crate_num, mutable pos: 0u,
-               len: vec::len(*data), tcx: tcx};
-    parse_bounds(st, sd)
-}
-
-fn parse_bounds(st: @pstate, sd: str_def) -> @[ty::param_bound] {
-    let bounds = [];
-    while peek(st) as char == '.' {
-        next(st);
-        bounds += [alt next(st) as char {
-          'S' { ty::bound_send }
-          'C' { ty::bound_copy }
-          'I' { ty::bound_iface(parse_ty(st, sd)) }
-        }];
-    }
-    @bounds
-}
-
 //
 // Local Variables:
 // mode: rust