---

yaml
---
r: 60351
b: refs/heads/master
c: 109bb7c
h: refs/heads/master
i:
  60349: 2f68d93
  60347: df05faf
  60343: 9c9eede
  60335: b25ae8c
  60319: 71a2d74
  60287: fd0036d
v: v3

Author: dotdash

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 217f96339a168db3e25ba4b09c0fbc226a613b16
+refs/heads/master: 109bb7c78ba64462a02c6a2653243e063113dcb6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589

trunk/src/libcore/hashmap.rs

@@ -825,6 +825,10 @@ pub impl <T:Hash + Eq> HashSet<T> {
     fn consume(&mut self, f: &fn(T)) {
         self.map.consume(|k, _| f(k))
     }
+
+    fn contains_equiv<Q:Hash + Equiv<T>>(&self, value: &Q) -> bool {
+      self.map.contains_key_equiv(value)
+    }
 }
 
 #[cfg(test)]

trunk/src/librustc/metadata/common.rs

@@ -100,7 +100,7 @@ pub static tag_mod_impl_trait: uint = 0x47u;
   different tags.
  */
 pub static tag_item_impl_method: uint = 0x48u;
-pub static tag_item_trait_method_explicit_self: uint = 0x4b;
+pub static tag_item_trait_method_self_ty: uint = 0x4b;
 pub static tag_item_trait_method_self_ty_region: uint = 0x4c;
 
 

trunk/src/librustc/metadata/csearch.rs

@@ -22,7 +22,7 @@ use syntax::ast_map;
 use syntax::diagnostic::expect;
 
 pub struct ProvidedTraitMethodInfo {
-    ty: ty::Method,
+    ty: ty::method,
     def_id: ast::def_id
 }
 
@@ -129,18 +129,17 @@ pub fn get_impls_for_mod(cstore: @mut cstore::CStore, def: ast::def_id,
 }
 
 pub fn get_method(tcx: ty::ctxt,
-                  def: ast::def_id) -> ty::Method
+                  def: ast::def_id) -> ty::method
 {
     let cdata = cstore::get_crate_data(tcx.cstore, def.crate);
     decoder::get_method(tcx.cstore.intr, cdata, def.node, tcx)
 }
 
-pub fn get_method_name_and_explicit_self(cstore: @mut cstore::CStore,
-                                         def: ast::def_id)
-                                     -> (ast::ident, ast::explicit_self_)
+pub fn get_method_name_and_self_ty(cstore: @mut cstore::CStore,
+                                   def: ast::def_id) -> (ast::ident, ast::self_ty_)
 {
     let cdata = cstore::get_crate_data(cstore, def.crate);
-    decoder::get_method_name_and_explicit_self(cstore.intr, cdata, def.node)
+    decoder::get_method_name_and_self_ty(cstore.intr, cdata, def.node)
 }
 
 pub fn get_trait_method_def_ids(cstore: @mut cstore::CStore,

trunk/src/librustc/metadata/decoder.rs

@@ -653,7 +653,7 @@ pub fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                                 item, tcx, cdata);
         let name = item_name(intr, item);
         let arg_tys = match ty::get(ctor_ty).sty {
-          ty::ty_bare_fn(ref f) => copy f.sig.inputs,
+          ty::ty_bare_fn(ref f) => f.sig.inputs.map(|a| a.ty),
           _ => ~[], // Nullary enum variant.
         };
         match variant_disr_val(item) {
@@ -670,7 +670,7 @@ pub fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id,
     return infos;
 }
 
-fn get_explicit_self(item: ebml::Doc) -> ast::explicit_self_ {
+fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ {
     fn get_mutability(ch: u8) -> ast::mutability {
         match ch as char {
             'i' => { ast::m_imm }
@@ -682,11 +682,11 @@ 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 = reader::doc_as_str(explicit_self_doc);
+    let self_type_doc = reader::get_doc(item, tag_item_trait_method_self_ty);
+    let string = reader::doc_as_str(self_type_doc);
 
-    let explicit_self_kind = string[0];
-    match explicit_self_kind as char {
+    let self_ty_kind = string[0];
+    match self_ty_kind as char {
         's' => { return ast::sty_static; }
         'v' => { return ast::sty_value; }
         '@' => { return ast::sty_box(get_mutability(string[1])); }
@@ -696,7 +696,7 @@ fn get_explicit_self(item: ebml::Doc) -> ast::explicit_self_ {
             return ast::sty_region(None, get_mutability(string[1]));
         }
         _ => {
-            fail!("unknown self type code: `%c`", explicit_self_kind as char);
+            fail!("unknown self type code: `%c`", self_ty_kind as char);
         }
     }
 }
@@ -707,12 +707,12 @@ fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc,
     for reader::tagged_docs(item, tag_item_impl_method) |doc| {
         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);
+        let self_ty = get_self_ty(mth_item);
         rslt.push(@resolve::MethodInfo {
                     did: translate_def_id(cdata, m_did),
                     n_tps: item_ty_param_count(mth_item) - base_tps,
                     ident: item_name(intr, mth_item),
-                    explicit_self: explicit_self});
+                    self_type: self_ty});
     }
     rslt
 }
@@ -748,19 +748,19 @@ pub fn get_impls_for_mod(intr: @ident_interner,
     @result
 }
 
-pub fn get_method_name_and_explicit_self(
+pub fn get_method_name_and_self_ty(
     intr: @ident_interner,
     cdata: cmd,
-    id: ast::node_id) -> (ast::ident, ast::explicit_self_)
+    id: ast::node_id) -> (ast::ident, ast::self_ty_)
 {
     let method_doc = lookup_item(id, cdata.data);
     let name = item_name(intr, method_doc);
-    let explicit_self = get_explicit_self(method_doc);
-    (name, explicit_self)
+    let self_ty = get_self_ty(method_doc);
+    (name, self_ty)
 }
 
 pub fn get_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
-                  tcx: ty::ctxt) -> ty::Method
+                  tcx: ty::ctxt) -> ty::method
 {
     let method_doc = lookup_item(id, cdata.data);
     let def_id = item_def_id(method_doc, cdata);
@@ -770,20 +770,19 @@ pub fn get_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
     let transformed_self_ty = doc_transformed_self_ty(method_doc, tcx, cdata);
     let fty = doc_method_fty(method_doc, tcx, cdata);
     let vis = item_visibility(method_doc);
-    let explicit_self = get_explicit_self(method_doc);
-
-    ty::Method::new(
-        name,
-        ty::Generics {
+    let self_ty = get_self_ty(method_doc);
+    ty::method {
+        ident: name,
+        generics: ty::Generics {
             type_param_defs: type_param_defs,
             region_param: None
         },
-        transformed_self_ty,
-        fty,
-        explicit_self,
-        vis,
-        def_id
-    )
+        transformed_self_ty: transformed_self_ty,
+        fty: fty,
+        self_ty: self_ty,
+        vis: vis,
+        def_id: def_id
+    }
 }
 
 pub fn get_trait_method_def_ids(cdata: cmd,
@@ -824,20 +823,19 @@ pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
         };
 
         let transformed_self_ty = doc_transformed_self_ty(mth, tcx, cdata);
-        let explicit_self = get_explicit_self(mth);
-
-        let ty_method = ty::Method::new(
-            name,
-            ty::Generics {
+        let self_ty = get_self_ty(mth);
+        let ty_method = ty::method {
+            ident: name,
+            generics: ty::Generics {
                 type_param_defs: type_param_defs,
                 region_param: None
             },
-            transformed_self_ty,
-            fty,
-            explicit_self,
-            ast::public,
-            did
-        );
+            transformed_self_ty: transformed_self_ty,
+            fty: fty,
+            self_ty: self_ty,
+            vis: ast::public,
+            def_id: did
+        };
         let provided_trait_method_info = ProvidedTraitMethodInfo {
             ty: ty_method,
             def_id: did

trunk/src/librustc/metadata/encoder.rs

@@ -366,7 +366,7 @@ fn encode_path(ecx: @EncodeContext,
 fn encode_reexported_static_method(ecx: @EncodeContext,
                                    ebml_w: &mut writer::Encoder,
                                    exp: &middle::resolve::Export2,
-                                   m: @ty::Method) {
+                                   m: @ty::method) {
     debug!("(encode static trait method) reexport '%s::%s'",
             *exp.name, *ecx.tcx.sess.str_of(m.ident));
     ebml_w.start_tag(tag_items_data_item_reexport);
@@ -389,7 +389,7 @@ fn encode_reexported_static_methods(ecx: @EncodeContext,
                 Some(&ast_map::node_item(_, path)) => {
                     if mod_path != *path {
                         for methods.each |&m| {
-                            if m.explicit_self == ast::sty_static {
+                            if m.self_ty  == ast::sty_static {
                                 encode_reexported_static_method(ecx,
                                                                 ebml_w,
                                                                 exp, m);
@@ -486,11 +486,11 @@ fn encode_visibility(ebml_w: &mut writer::Encoder, visibility: visibility) {
     ebml_w.end_tag();
 }
 
-fn encode_explicit_self(ebml_w: &mut writer::Encoder, explicit_self: ast::explicit_self_) {
-    ebml_w.start_tag(tag_item_trait_method_explicit_self);
+fn encode_self_type(ebml_w: &mut writer::Encoder, self_type: ast::self_ty_) {
+    ebml_w.start_tag(tag_item_trait_method_self_ty);
 
     // Encode the base self type.
-    match explicit_self {
+    match self_type {
         sty_static => {
             ebml_w.writer.write(&[ 's' as u8 ]);
         }
@@ -625,7 +625,7 @@ fn encode_info_for_struct_ctor(ecx: @EncodeContext,
 
 fn encode_method_ty_fields(ecx: @EncodeContext,
                            ebml_w: &mut writer::Encoder,
-                           method_ty: &ty::Method) {
+                           method_ty: &ty::method) {
     encode_def_id(ebml_w, method_ty.def_id);
     encode_name(ecx, ebml_w, method_ty.ident);
     encode_ty_type_param_defs(ebml_w, ecx,
@@ -634,7 +634,7 @@ fn encode_method_ty_fields(ecx: @EncodeContext,
     encode_transformed_self_ty(ecx, ebml_w, method_ty.transformed_self_ty);
     encode_method_fty(ecx, ebml_w, &method_ty.fty);
     encode_visibility(ebml_w, method_ty.vis);
-    encode_explicit_self(ebml_w, method_ty.explicit_self);
+    encode_self_type(ebml_w, method_ty.self_ty);
 }
 
 fn encode_info_for_method(ecx: @EncodeContext,
@@ -652,10 +652,10 @@ fn encode_info_for_method(ecx: @EncodeContext,
     ebml_w.start_tag(tag_items_data_item);
 
     let method_def_id = local_def(m.id);
-    let method_ty = ty::method(ecx.tcx, method_def_id);
+    let method_ty: @ty::method = ty::method(ecx.tcx, method_def_id);
     encode_method_ty_fields(ecx, ebml_w, method_ty);
 
-    match m.explicit_self.node {
+    match m.self_ty.node {
         ast::sty_static => {
             encode_family(ebml_w, purity_static_method_family(m.purity));
         }
@@ -948,7 +948,7 @@ fn encode_info_for_item(ecx: @EncodeContext,
         for ty::trait_method_def_ids(tcx, local_def(item.id)).eachi |i, &method_def_id| {
             assert!(method_def_id.crate == ast::local_crate);
 
-            let method_ty = ty::method(tcx, method_def_id);
+            let method_ty: @ty::method = ty::method(tcx, method_def_id);
 
             index.push(entry {val: method_def_id.node, pos: ebml_w.writer.tell()});
 
@@ -962,7 +962,7 @@ fn encode_info_for_item(ecx: @EncodeContext,
             trait_path.push(ast_map::path_name(item.ident));
             encode_path(ecx, ebml_w, trait_path, ast_map::path_name(method_ty.ident));
 
-            match method_ty.explicit_self {
+            match method_ty.self_ty {
                 sty_static => {
                     encode_family(ebml_w,
                                   purity_static_method_family(
@@ -991,7 +991,7 @@ fn encode_info_for_item(ecx: @EncodeContext,
                     // This is obviously a bogus assert but I don't think this
                     // ever worked before anyhow...near as I can tell, before
                     // we would emit two items.
-                    if method_ty.explicit_self == sty_static {
+                    if method_ty.self_ty == sty_static {
                         tcx.sess.span_unimpl(
                             item.span,
                             fmt!("Method %s is both provided and static",

trunk/src/librustc/metadata/tydecode.rs

@@ -126,6 +126,12 @@ pub fn parse_trait_ref_data(data: @~[u8], crate_num: int, pos: uint, tcx: ty::ct
     parse_trait_ref(st, conv)
 }
 
+pub fn parse_arg_data(data: @~[u8], crate_num: int, pos: uint, tcx: ty::ctxt,
+                      conv: conv_did) -> ty::arg {
+    let st = parse_state_from_data(data, crate_num, pos, tcx);
+    parse_arg(st, conv)
+}
+
 fn parse_path(st: @mut PState) -> @ast::Path {
     let mut idents: ~[ast::ident] = ~[];
     fn is_last(c: char) -> bool { return c == '(' || c == ':'; }
@@ -465,6 +471,12 @@ fn parse_onceness(c: char) -> ast::Onceness {
     }
 }
 
+fn parse_arg(st: @mut PState, conv: conv_did) -> ty::arg {
+    ty::arg {
+        ty: parse_ty(st, conv)
+    }
+}
+
 fn parse_closure_ty(st: @mut PState, conv: conv_did) -> ty::ClosureTy {
     let sigil = parse_sigil(st);
     let purity = parse_purity(next(st));
@@ -493,9 +505,9 @@ fn parse_bare_fn_ty(st: @mut PState, conv: conv_did) -> ty::BareFnTy {
 
 fn parse_sig(st: @mut PState, conv: conv_did) -> ty::FnSig {
     assert!((next(st) == '['));
-    let mut inputs = ~[];
+    let mut inputs: ~[ty::arg] = ~[];
     while peek(st) != ']' {
-        inputs.push(parse_ty(st, conv));
+        inputs.push(ty::arg { ty: parse_ty(st, conv) });
     }
     st.pos += 1u; // eat the ']'
     let ret_ty = parse_ty(st, conv);

trunk/src/librustc/metadata/tyencode.rs

@@ -344,6 +344,10 @@ fn enc_sigil(w: @io::Writer, sigil: Sigil) {
     }
 }
 
+pub fn enc_arg(w: @io::Writer, cx: @ctxt, arg: ty::arg) {
+    enc_ty(w, cx, arg.ty);
+}
+
 fn enc_purity(w: @io::Writer, p: purity) {
     match p {
       pure_fn => w.write_char('p'),
@@ -385,8 +389,8 @@ fn enc_closure_ty(w: @io::Writer, cx: @ctxt, ft: &ty::ClosureTy) {
 
 fn enc_fn_sig(w: @io::Writer, cx: @ctxt, fsig: &ty::FnSig) {
     w.write_char('[');
-    for fsig.inputs.each |ty| {
-        enc_ty(w, cx, *ty);
+    for fsig.inputs.each |arg| {
+        enc_arg(w, cx, *arg);
     }
     w.write_char(']');
     enc_ty(w, cx, fsig.output);