Support Sized bounds for associated types

src/librustc/middle/astencode.rs

@@ -81,7 +81,7 @@ pub fn encode_inlined_item(ecx: &e::EncodeContext,
         e::IIForeignRef(i) => i.id,
         e::IITraitItemRef(_, &ast::ProvidedMethod(ref m)) => m.id,
         e::IITraitItemRef(_, &ast::RequiredMethod(ref m)) => m.id,
-        e::IITraitItemRef(_, &ast::TypeTraitItem(ref ti)) => ti.id,
+        e::IITraitItemRef(_, &ast::TypeTraitItem(ref ti)) => ti.ty_param.id,
         e::IIImplItemRef(_, &ast::MethodImplItem(ref m)) => m.id,
         e::IIImplItemRef(_, &ast::TypeImplItem(ref ti)) => ti.id,
     };
@@ -156,7 +156,7 @@ pub fn decode_inlined_item<'tcx>(cdata: &cstore::crate_metadata,
                 match *ti {
                     ast::ProvidedMethod(ref m) => m.pe_ident(),
                     ast::RequiredMethod(ref ty_m) => ty_m.ident,
-                    ast::TypeTraitItem(ref ti) => ti.ident,
+                    ast::TypeTraitItem(ref ti) => ti.ty_param.ident,
                 }
             },
             ast::IIImplItem(_, ref m) => {
@@ -717,8 +717,9 @@ impl<'a> vtable_decoder_helpers for reader::Decoder<'a> {
     {
         let types = self.read_to_vec(|this| Ok(f(this))).unwrap();
         let selfs = self.read_to_vec(|this| Ok(f(this))).unwrap();
+        let assocs = self.read_to_vec(|this| Ok(f(this))).unwrap();
         let fns = self.read_to_vec(|this| Ok(f(this))).unwrap();
-        VecPerParamSpace::new(types, selfs, fns)
+        VecPerParamSpace::new(types, selfs, assocs, fns)
     }
 
     fn read_vtable_res_with_key(&mut self,

src/librustc/middle/privacy.rs

@@ -296,8 +296,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> {
                             self.exported_items.insert(m.id);
                         }
                         ast::TypeTraitItem(ref t) => {
-                            debug!("typedef {}", t.id);
-                            self.exported_items.insert(t.id);
+                            debug!("typedef {}", t.ty_param.id);
+                            self.exported_items.insert(t.ty_param.id);
                         }
                     }
                 }

src/librustc/middle/resolve.rs

@@ -1559,19 +1559,19 @@ impl<'a> Resolver<'a> {
                         }
                         ast::TypeTraitItem(ref associated_type) => {
                             let def = DefAssociatedTy(local_def(
-                                    associated_type.id));
+                                    associated_type.ty_param.id));
 
                             let name_bindings =
-                                self.add_child(associated_type.ident.name,
+                                self.add_child(associated_type.ty_param.ident.name,
                                                module_parent.clone(),
                                                ForbidDuplicateTypesAndValues,
-                                               associated_type.span);
+                                               associated_type.ty_param.span);
                             // NB: not IMPORTABLE
                             name_bindings.define_type(def,
-                                                      associated_type.span,
+                                                      associated_type.ty_param.span,
                                                       PUBLIC);
 
-                            (associated_type.ident.name, TypeTraitItemKind)
+                            (associated_type.ty_param.ident.name, TypeTraitItemKind)
                         }
                     };
 
@@ -4218,7 +4218,7 @@ impl<'a> Resolver<'a> {
                                             impl_items.as_slice());
             }
 
-            ItemTrait(ref generics, ref unbound, ref bounds, ref methods) => {
+            ItemTrait(ref generics, ref unbound, ref bounds, ref trait_items) => {
                 // Create a new rib for the self type.
                 let mut self_type_rib = Rib::new(ItemRibKind);
 
@@ -4246,13 +4246,13 @@ impl<'a> Resolver<'a> {
                         _ => {}
                     }
 
-                    for method in (*methods).iter() {
-                        // Create a new rib for the method-specific type
+                    for trait_item in (*trait_items).iter() {
+                        // Create a new rib for the trait_item-specific type
                         // parameters.
                         //
                         // FIXME #4951: Do we need a node ID here?
 
-                        match *method {
+                        match *trait_item {
                           ast::RequiredMethod(ref ty_m) => {
                             this.with_type_parameter_rib
                                 (HasTypeParameters(&ty_m.generics,
@@ -4287,8 +4287,9 @@ impl<'a> Resolver<'a> {
                                                                 ProvidedMethod(m.id)),
                                                   &**m)
                           }
-                          ast::TypeTraitItem(_) => {
-                              visit::walk_trait_item(this, method);
+                          ast::TypeTraitItem(ref data) => {
+                              this.resolve_type_parameter(&data.ty_param);
+                              visit::walk_trait_item(this, trait_item);
                           }
                         }
                     }
@@ -4477,20 +4478,25 @@ impl<'a> Resolver<'a> {
     fn resolve_type_parameters(&mut self,
                                type_parameters: &OwnedSlice<TyParam>) {
         for type_parameter in type_parameters.iter() {
-            for bound in type_parameter.bounds.iter() {
-                self.resolve_type_parameter_bound(type_parameter.id, bound,
-                                                  TraitBoundingTypeParameter);
-            }
-            match &type_parameter.unbound {
-                &Some(ref unbound) =>
-                    self.resolve_type_parameter_bound(
-                        type_parameter.id, unbound, TraitBoundingTypeParameter),
-                &None => {}
-            }
-            match type_parameter.default {
-                Some(ref ty) => self.resolve_type(&**ty),
-                None => {}
-            }
+            self.resolve_type_parameter(type_parameter);
+        }
+    }
+
+    fn resolve_type_parameter(&mut self,
+                              type_parameter: &TyParam) {
+        for bound in type_parameter.bounds.iter() {
+            self.resolve_type_parameter_bound(type_parameter.id, bound,
+                                              TraitBoundingTypeParameter);
+        }
+        match &type_parameter.unbound {
+            &Some(ref unbound) =>
+                self.resolve_type_parameter_bound(
+                    type_parameter.id, unbound, TraitBoundingTypeParameter),
+            &None => {}
+        }
+        match type_parameter.default {
+            Some(ref ty) => self.resolve_type(&**ty),
+            None => {}
         }
     }
 
@@ -4577,14 +4583,14 @@ impl<'a> Resolver<'a> {
                         self.resolve_error(trait_reference.path.span,
                                            format!("`{}` is not a trait",
                                                    self.path_names_to_string(
-                                                        &trait_reference.path)));
+                                                       &trait_reference.path)));
 
                         // If it's a typedef, give a note
                         match def {
                             DefTy(..) => {
                                 self.session.span_note(
-                                                trait_reference.path.span,
-                                                format!("`type` aliases cannot \
+                                    trait_reference.path.span,
+                                    format!("`type` aliases cannot \
                                                         be used for traits")
                                                         .as_slice());
                             }

src/librustc/middle/stability.rs

@@ -86,7 +86,7 @@ impl<'v> Visitor<'v> for Annotator {
                 }
             }
 
-            TypeTraitItem(ref typedef) => (typedef.id, &typedef.attrs),
+            TypeTraitItem(ref typedef) => (typedef.ty_param.id, &typedef.attrs),
         };
         self.annotate(id, attrs, |v| visit::walk_trait_item(v, t));
     }