Make default associated types not parse

They don't do anything ATM.

This is a
[breaking-change]

Author: arielb1

src/libcore/ops.rs

@@ -405,7 +405,7 @@ div_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
 pub trait Rem<RHS=Self> {
     /// The resulting type after applying the `%` operator
     #[stable(feature = "rust1", since = "1.0.0")]
-    type Output = Self;
+    type Output;
 
     /// The method for the `%` operator
     #[stable(feature = "rust1", since = "1.0.0")]

src/librustc_typeck/collect.rs

@@ -1376,7 +1376,7 @@ fn convert_trait_predicates<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, it: &ast::Item)
     {
         trait_items.iter().flat_map(|trait_item| {
             let bounds = match trait_item.node {
-                ast::TypeTraitItem(ref bounds, _) => bounds,
+                ast::TypeTraitItem(ref bounds) => bounds,
                 _ => {
                     return vec!().into_iter();
                 }

src/librustdoc/clean/mod.rs

@@ -1247,8 +1247,8 @@ impl Clean<Item> for ast::TraitItem {
             ast::MethodTraitItem(ref sig, None) => {
                 TyMethodItem(sig.clean(cx))
             }
-            ast::TypeTraitItem(ref bounds, ref default) => {
-                AssociatedTypeItem(bounds.clean(cx), default.clean(cx))
+            ast::TypeTraitItem(ref bounds) => {
+                AssociatedTypeItem(bounds.clean(cx), None)
             }
         };
         Item {

src/libsyntax/ast.rs

@@ -1238,7 +1238,7 @@ pub struct TraitItem {
 pub enum TraitItem_ {
     ConstTraitItem(P<Ty>, Option<P<Expr>>),
     MethodTraitItem(MethodSig, Option<P<Block>>),
-    TypeTraitItem(TyParamBounds, Option<P<Ty>>),
+    TypeTraitItem(TyParamBounds),
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]

src/libsyntax/fold.rs

@@ -991,9 +991,8 @@ pub fn noop_fold_trait_item<T: Folder>(i: P<TraitItem>, folder: &mut T)
                 MethodTraitItem(noop_fold_method_sig(sig, folder),
                                 body.map(|x| folder.fold_block(x)))
             }
-            TypeTraitItem(bounds, default) => {
-                TypeTraitItem(folder.fold_bounds(bounds),
-                              default.map(|x| folder.fold_ty(x)))
+            TypeTraitItem(bounds) => {
+                TypeTraitItem(folder.fold_bounds(bounds))
             }
         },
         span: folder.new_span(span)

src/libsyntax/parse/parser.rs

@@ -1158,8 +1158,12 @@ impl<'a> Parser<'a> {
 
             let (name, node) = if try!(p.eat_keyword(keywords::Type)) {
                 let TyParam {ident, bounds, default, ..} = try!(p.parse_ty_param());
+                if let Some(dty) = default {
+                    p.span_err(dty.span,
+                               "defaults are not supported in associated types");
+                }
                 try!(p.expect(&token::Semi));
-                (ident, TypeTraitItem(bounds, default))
+                (ident, TypeTraitItem(bounds))
             } else if try!(p.eat_keyword(keywords::Const)) {
                 let ident = try!(p.parse_ident());
                 try!(p.expect(&token::Colon));

src/libsyntax/print/pprust.rs

@@ -1272,9 +1272,8 @@ impl<'a> State<'a> {
                     try!(word(&mut self.s, ";"));
                 }
             }
-            ast::TypeTraitItem(ref bounds, ref default) => {
-                try!(self.print_associated_type(ti.ident, Some(bounds),
-                                                default.as_ref().map(|ty| &**ty)));
+            ast::TypeTraitItem(ref bounds) => {
+                try!(self.print_associated_type(ti.ident, Some(bounds), None))
             }
         }
         self.ann.post(self, NodeSubItem(ti.id))

src/libsyntax/visit.rs

@@ -638,9 +638,8 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v Trai
             visitor.visit_fn(FkMethod(trait_item.ident, sig, None), &sig.decl,
                              body, trait_item.span, trait_item.id);
         }
-        TypeTraitItem(ref bounds, ref default) => {
+        TypeTraitItem(ref bounds) => {
             walk_ty_param_bounds_helper(visitor, bounds);
-            walk_ty_opt(visitor, default);
         }
     }
 }

src/test/auxiliary/lang-item-public.rs

@@ -31,7 +31,7 @@ pub trait Copy {
 
 #[lang="rem"]
 pub trait Rem<RHS=Self> {
-    type Output = Self;
+    type Output;
     fn rem(self, rhs: RHS) -> Self::Output;
 }
 

src/test/compile-fail/issue-22673.rs

@@ -10,7 +10,7 @@
 
 trait Expr : PartialEq<Self::Item> {
     //~^ ERROR: unsupported cyclic reference between types/traits detected
-    type Item = Expr;
+    type Item;
 }
 
 fn main() {}