Change representation of type params to handle interface bounds

Issue #1227

Author: marijnh

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_kinds: uint = 0x0bu;
+const tag_items_data_item_ty_param_bounds: uint = 0x0bu;
 
 const tag_items_data_item_type: uint = 0x0cu;
 

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_kinds_and_ty {
+fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty {
     let cstore = tcx.sess.get_cstore();
     let cnum = def.crate;
     let cdata = cstore::get_crate_data(cstore, cnum).data;

src/comp/metadata/decoder.rs

@@ -14,7 +14,6 @@ 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;
@@ -90,21 +89,22 @@ 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,32 +115,24 @@ fn item_type(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
     t
 }
 
-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_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_count(item: ebml::doc) -> uint {
     let n = 0u;
-    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;
+    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; }
+        }
     }
     n
 }
@@ -213,28 +205,21 @@ 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_kinds_and_ty {
+            extres: external_resolver) -> ty::ty_param_bounds_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_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};
+    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};
 }
 
 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));
 }

src/comp/metadata/encoder.rs

@@ -183,18 +183,17 @@ 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_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]);
+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);
     }
-    ebml::end_tag(ebml_w);
 }
 
 fn encode_variant_id(ebml_w: ebml::writer, vid: def_id) {
@@ -205,9 +204,8 @@ 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: f,
+        @{ds: def_to_str,
           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);
@@ -247,7 +245,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_kinds(ebml_w, ty_params);
+        encode_type_param_bounds(ebml_w, ecx, ty_params);
         ebml::end_tag(ebml_w);
     }
 }
@@ -293,7 +291,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_kinds(ebml_w, tps);
+        encode_type_param_bounds(ebml_w, ecx, 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);
@@ -312,7 +310,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_kinds(ebml_w, tps);
+        encode_type_param_bounds(ebml_w, ecx, 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);
@@ -321,7 +319,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_kinds(ebml_w, tps);
+        encode_type_param_bounds(ebml_w, ecx, 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 {
@@ -336,7 +334,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_kinds(ebml_w, tps);
+        encode_type_param_bounds(ebml_w, ecx, 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);
@@ -346,7 +344,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_kinds(ebml_w, tps);
+        encode_type_param_bounds(ebml_w, ecx, tps);
         encode_type(ecx, ebml_w, fn_ty);
         encode_symbol(ecx, ebml_w, ctor_id);
         ebml::end_tag(ebml_w);
@@ -357,7 +355,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_kinds(ebml_w, tps);
+        encode_type_param_bounds(ebml_w, ecx, 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);
@@ -366,7 +364,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_kinds(ebml_w, tps);
+        encode_type_param_bounds(ebml_w, ecx, tps);
         encode_type(ecx, ebml_w, fn_ty);
         encode_symbol(ecx, ebml_w, ctor_id);
         ebml::end_tag(ebml_w);
@@ -375,7 +373,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_kinds(ebml_w, tps);
+        encode_type_param_bounds(ebml_w, ecx, 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 {
@@ -390,7 +388,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_kinds(ebml_w, tps + m.tps);
+            encode_type_param_bounds(ebml_w, ecx, tps + m.tps);
             encode_type(ecx, ebml_w,
                         node_id_to_monotype(ecx.ccx.tcx, m.id));
             encode_name(ebml_w, m.ident);
@@ -421,7 +419,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_kinds(ebml_w, tps);
+        encode_type_param_bounds(ebml_w, ecx, tps);
         encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, nitem.id));
         encode_symbol(ecx, ebml_w, nitem.id);
       }

src/comp/metadata/tydecode.rs

@@ -10,6 +10,7 @@ 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
@@ -21,7 +22,9 @@ 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 { ret st.data[st.pos]; }
+fn peek(st: @pstate) -> u8 {
+    if st.pos < vec::len(*st.data) { st.data[st.pos] } else { 0u8 }
+}
 
 fn next(st: @pstate) -> u8 {
     let ch = st.data[st.pos];
@@ -48,8 +51,7 @@ 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};
-    let result = parse_ty(st, sd);
-    ret result;
+    parse_ty(st, sd)
 }
 
 fn parse_ret_ty(st: @pstate, sd: str_def) -> (ast::ret_style, ty::t) {
@@ -201,18 +203,8 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
         ret ty::mk_tag(st.tcx, def, params);
       }
       'p' {
-        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);
+        let bounds = parse_bounds(st, sd);
+        ret ty::mk_param(st.tcx, parse_int(st) as uint, bounds);
       }
       '@' { ret ty::mk_box(st.tcx, parse_mt(st, sd)); }
       '~' { ret ty::mk_uniq(st.tcx, parse_mt(st, sd)); }
@@ -400,6 +392,26 @@ 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