rustc: Implement multiple-traits-per-impl for cross-crate stuff

Author: pcwalton

src/rustc/metadata/csearch.rs

@@ -27,7 +27,7 @@ export get_trait_methods;
 export get_method_names_if_trait;
 export each_path;
 export get_type;
-export get_impl_trait;
+export get_impl_traits;
 export get_impl_method;
 export get_item_path;
 export maybe_get_item_ast, found_ast, found, found_parent, not_found;
@@ -187,12 +187,13 @@ fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id,
     ret {bounds: @~[], rp: false, ty: ty};
 }
 
-// Given a def_id for an impl or class, return the trait it implements,
-// or none if it's not for an impl or for a class that implements traits
-fn get_impl_trait(tcx: ty::ctxt, def: ast::def_id) -> option<ty::t> {
+// Given a def_id for an impl or class, return the traits it implements,
+// or the empty vector if it's not for an impl or for a class that implements
+// traits
+fn get_impl_traits(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::t] {
     let cstore = tcx.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
-    decoder::get_impl_trait(cdata, def.node, tcx)
+    decoder::get_impl_traits(cdata, def.node, tcx)
 }
 
 fn get_impl_method(cstore: cstore::cstore,

src/rustc/metadata/decoder.rs

@@ -24,7 +24,7 @@ export get_enum_variants;
 export get_type;
 export get_region_param;
 export get_type_param_count;
-export get_impl_trait;
+export get_impl_traits;
 export get_class_method;
 export get_impl_method;
 export lookup_def;
@@ -168,13 +168,12 @@ fn item_type(item_id: ast::def_id, item: ebml::doc,
     } else { t }
 }
 
-fn item_impl_trait(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
-    -> option<ty::t> {
-    let mut result = none;
+fn item_impl_traits(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ~[ty::t] {
+    let mut results = ~[];
     do ebml::tagged_docs(item, tag_impl_trait) |ity| {
-        result = some(doc_type(ity, tcx, cdata));
+        vec::push(results, doc_type(ity, tcx, cdata));
     };
-    result
+    results
 }
 
 fn item_ty_param_bounds(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
@@ -333,9 +332,8 @@ fn get_type_param_count(data: @~[u8], id: ast::node_id) -> uint {
     item_ty_param_count(lookup_item(id, data))
 }
 
-fn get_impl_trait(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
-    -> option<ty::t> {
-    item_impl_trait(lookup_item(id, cdata.data), tcx, cdata)
+fn get_impl_traits(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) -> ~[ty::t] {
+    item_impl_traits(lookup_item(id, cdata.data), tcx, cdata)
 }
 
 fn get_impl_method(cdata: cmd, id: ast::node_id,

src/rustc/middle/ty.rs

@@ -2507,15 +2507,7 @@ fn impl_traits(cx: ctxt, id: ast::def_id) -> ~[t] {
            _ { ~[] }
         }
     } else {
-        // XXX: csearch::get_impl_trait should return a vector.
-        alt csearch::get_impl_trait(cx, id) {
-            none {
-                ~[]
-            }
-            some(trait_ref) {
-                ~[trait_ref]
-            }
-        }
+        csearch::get_impl_traits(cx, id)
     }
 }
 

src/rustc/middle/typeck/coherence.rs

@@ -4,7 +4,7 @@
 // has at most one implementation for each type. Then we build a mapping from
 // each trait in the system to its implementations.
 
-import metadata::csearch::{each_path, get_impl_trait, get_impls_for_mod};
+import metadata::csearch::{each_path, get_impl_traits, get_impls_for_mod};
 import metadata::cstore::{cstore, iter_crate_data};
 import metadata::decoder::{dl_def, dl_field, dl_impl};
 import middle::resolve3::Impl;
@@ -546,45 +546,40 @@ class CoherenceChecker {
 
             let self_type = lookup_item_type(self.crate_context.tcx,
                                              implementation.did);
-            let optional_trait =
-                get_impl_trait(self.crate_context.tcx,
-                               implementation.did);
-            alt optional_trait {
-                none {
-                    // This is an inherent method. There should be
-                    // no problems here, but perform a sanity check
-                    // anyway.
-
-                    alt get_base_type_def_id(self.inference_context,
-                                             dummy_sp(),
-                                             self_type.ty) {
-                        none {
-                            let session = self.crate_context.tcx.sess;
-                            session.bug(#fmt("no base type for \
-                                              external impl with no \
-                                              trait: %s (type %s)!",
-                                             *implementation.ident,
-                                             ty_to_str
-                                             (self.crate_context.tcx,
-                                              self_type.ty)));
-                        }
-                        some(_) {
-                            // Nothing to do.
-                        }
+            let associated_traits = get_impl_traits(self.crate_context.tcx,
+                                                    implementation.did);
+
+            // Do a sanity check to make sure that inherent methods have base
+            // types.
+
+            if associated_traits.len() == 0 {
+                alt get_base_type_def_id(self.inference_context,
+                                         dummy_sp(),
+                                         self_type.ty) {
+                    none {
+                        let session = self.crate_context.tcx.sess;
+                        session.bug(#fmt("no base type for external impl \
+                                          with no trait: %s (type %s)!",
+                                         *implementation.ident,
+                                         ty_to_str(self.crate_context.tcx,
+                                                   self_type.ty)));
+                    }
+                    some(_) {
+                        // Nothing to do.
                     }
                 }
+            }
 
-                some(trait_type) {
-                    alt get(trait_type).struct {
-                        ty_trait(trait_id, _) {
-                            self.add_trait_method(trait_id,
-                                                  implementation);
-                        }
-                        _ {
-                            self.crate_context.tcx.sess
-                                .bug(~"trait type returned is not a \
-                                       trait");
-                        }
+            // Record all the trait methods.
+            for associated_traits.each |trait_type| {
+                alt get(trait_type).struct {
+                    ty_trait(trait_id, _) {
+                        self.add_trait_method(trait_id, implementation);
+                    }
+                    _ {
+                        self.crate_context.tcx.sess.bug(~"trait type \
+                                                          returned is not a \
+                                                          trait");
                     }
                 }
             }