Remove support for multiple traits in a single impl

There was half-working support for them, but they were never fully
implemented or even approved. Remove them altogether.

Closes #3410

src/rustc/metadata/encoder.rs

@@ -699,7 +699,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
                                  else { None }, tps);
         }
       }
-      item_impl(tps, traits, _, methods) => {
+      item_impl(tps, opt_trait, _, methods) => {
         add_to_index();
         ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
@@ -714,10 +714,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
             ebml_w.writer.write(str::to_bytes(def_to_str(local_def(m.id))));
             ebml_w.end_tag();
         }
-        if traits.len() > 1 {
-            fail ~"multiple traits!!";
-        }
-        for traits.each |associated_trait| {
+        do opt_trait.iter() |associated_trait| {
            encode_trait_ref(ebml_w, ecx, associated_trait)
         }
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));

src/rustc/middle/resolve.rs

@@ -3532,7 +3532,7 @@ struct Resolver {
     fn resolve_implementation(id: node_id,
                               span: span,
                               type_parameters: ~[ty_param],
-                              trait_references: ~[@trait_ref],
+                              opt_trait_reference: Option<@trait_ref>,
                               self_type: @ty,
                               methods: ~[@method],
                               visitor: ResolveVisitor) {
@@ -3549,10 +3549,10 @@ struct Resolver {
 
             // Resolve the trait reference, if necessary.
             let original_trait_refs = self.current_trait_refs;
-            if trait_references.len() >= 1 {
-                let mut new_trait_refs = @DVec();
-                for trait_references.each |trait_reference| {
-                    match self.resolve_path(
+            match opt_trait_reference {
+              Some(trait_reference) => {
+                let new_trait_refs = @DVec();
+                match self.resolve_path(
                         trait_reference.path, TypeNS, true, visitor) {
                         None => {
                             self.session.span_err(span,
@@ -3566,11 +3566,11 @@ struct Resolver {
                             (*new_trait_refs).push(def_id_of_def(def));
                         }
                     }
-                }
-
                 // Record the current set of trait references.
                 self.current_trait_refs = Some(new_trait_refs);
             }
+            None => ()
+            }
 
             // Resolve the self type.
             self.resolve_type(self_type, visitor);

src/rustc/middle/ty.rs

@@ -3121,13 +3121,13 @@ fn impl_traits(cx: ctxt, id: ast::def_id) -> ~[t] {
         debug!("(impl_traits) searching for trait impl %?", id);
         match cx.items.find(id.node) {
            Some(ast_map::node_item(@{
-                        node: ast::item_impl(_, trait_refs, _, _),
+                        node: ast::item_impl(_, opt_trait, _, _),
                         _},
                     _)) => {
 
-                do vec::map(trait_refs) |trait_ref| {
-                    node_id_to_type(cx, trait_ref.ref_id)
-                }
+               do option::map_default(opt_trait, ~[]) |trait_ref| {
+                       ~[node_id_to_type(cx, trait_ref.ref_id)]
+                   }
            }
            Some(ast_map::node_item(@{node: ast::item_class(sd,_),
                            _},_)) => {

src/rustc/middle/typeck/coherence.rs

@@ -231,8 +231,8 @@ struct CoherenceChecker {
                        self.crate_context.tcx.sess.str_of(item.ident));
 
                 match item.node {
-                    item_impl(_, associated_traits, _, _) => {
-                        self.check_implementation(item, associated_traits);
+                    item_impl(_, opt_trait, _, _) => {
+                        self.check_implementation(item, opt_trait.to_vec());
                     }
                     item_class(struct_def, _) => {
                         self.check_implementation(item, struct_def.traits);
@@ -432,7 +432,7 @@ struct CoherenceChecker {
                         // Then visit the module items.
                         visit_mod(module_, item.span, item.id, (), visitor);
                     }
-                    item_impl(_, associated_traits, _, _) => {
+                    item_impl(_, opt_trait, _, _) => {
                         match self.base_type_def_ids.find(
                             local_def(item.id)) {
 
@@ -453,7 +453,8 @@ struct CoherenceChecker {
                                     // if the traits are defined in the same
                                     // crate.
 
-                                    if associated_traits.len() == 0 {
+                                  match opt_trait {
+                                    None => {
                                         // There is no trait to implement, so
                                         // this is an error.
 
@@ -470,8 +471,10 @@ struct CoherenceChecker {
                                                           or new type \
                                                           instead");
                                     }
+                                    _ => ()
+                                  }
 
-                                    for associated_traits.each |trait_ref| {
+                                  do opt_trait.iter() |trait_ref| {
                                         // This is OK if and only if the
                                         // trait was defined in this
                                         // crate.