---

yaml
---
r: 172899
b: refs/heads/batch
c: 24ace16
h: refs/heads/master
i:
  172897: 10fcc3f
  172895: eadf5e0
v: v3

Author: mdinger

[refs]

@@ -29,7 +29,7 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/issue-18208-method-dispatch-2: 9e1eae4fb9b6527315b4441cf8a0f5ca911d1671
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
-refs/heads/batch: 486f60df8797aa96e0a459227089945d06b88303
+refs/heads/batch: 24ace1665a38f575d8bf478fbfadef29ed9f17a9
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 44a287e6eb22ec3c2a687fc156813577464017f7
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928

branches/batch/src/doc/reference.md

@@ -2117,13 +2117,6 @@ macro scope.
   destructors from being run twice. Destructors might be run multiple times on
   the same object with this attribute.
 - `doc` - Doc comments such as `/// foo` are equivalent to `#[doc = "foo"]`.
-- `rustc_on_unimplemented` - Write a custom note to be shown along with the error
-   when the trait is found to be unimplemented on a type.
-   You may use format arguments like `{T}`, `{A}` to correspond to the
-   types at the point of use corresponding to the type parameters of the
-   trait of the same name. `{Self}` will be replaced with the type that is supposed
-   to implement the trait but doesn't. To use this, the `on_unimplemented` feature gate
-   must be enabled.
 
 ### Conditional compilation
 

branches/batch/src/libcore/iter.rs

@@ -101,8 +101,6 @@ pub trait Iterator {
 
 /// Conversion from an `Iterator`
 #[stable]
-#[rustc_on_unimplemented="a collection of type `{Self}` cannot be \
-                          built from an iterator over elements of type `{A}`"]
 pub trait FromIterator<A> {
     /// Build a container with elements from an external iterator.
     fn from_iter<T: Iterator<Item=A>>(iterator: T) -> Self;

branches/batch/src/libcore/lib.rs

@@ -63,7 +63,6 @@
 #![feature(simd, unsafe_destructor, slicing_syntax)]
 #![feature(unboxed_closures)]
 #![allow(unknown_features)] #![feature(int_uint)]
-#![feature(on_unimplemented)]
 #![deny(missing_docs)]
 
 #[macro_use]

branches/batch/src/librustc/lib.rs

@@ -32,7 +32,6 @@
 
 extern crate arena;
 extern crate flate;
-extern crate fmt_macros;
 extern crate getopts;
 extern crate graphviz;
 extern crate libc;

branches/batch/src/librustc/lint/builtin.rs

@@ -666,7 +666,6 @@ impl LintPass for UnusedAttributes {
             "must_use",
             "stable",
             "unstable",
-            "rustc_on_unimplemented",
 
             // FIXME: #19470 this shouldn't be needed forever
             "old_orphan_check",

branches/batch/src/librustc/middle/traits/error_reporting.rs

@@ -18,12 +18,9 @@ use super::{
     SelectionError,
 };
 
-use fmt_macros::{Parser, Piece, Position};
 use middle::infer::InferCtxt;
-use middle::ty::{self, AsPredicate, ReferencesError, ToPolyTraitRef, TraitRef};
-use std::collections::HashMap;
-use syntax::codemap::{DUMMY_SP, Span};
-use syntax::attr::{AttributeMethods, AttrMetaMethods};
+use middle::ty::{self, AsPredicate, ReferencesError, ToPolyTraitRef};
+use syntax::codemap::Span;
 use util::ppaux::{Repr, UserString};
 
 pub fn report_fulfillment_errors<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
@@ -65,85 +62,6 @@ pub fn report_projection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
     }
 }
 
-fn report_on_unimplemented<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
-                                     trait_ref: &TraitRef<'tcx>,
-                                     span: Span) -> Option<String> {
-    let def_id = trait_ref.def_id;
-    let mut report = None;
-    ty::each_attr(infcx.tcx, def_id, |item| {
-        if item.check_name("rustc_on_unimplemented") {
-            let err_sp = if item.meta().span == DUMMY_SP {
-                span
-            } else {
-                item.meta().span
-            };
-            let def = ty::lookup_trait_def(infcx.tcx, def_id);
-            let trait_str = def.trait_ref.user_string(infcx.tcx);
-            if let Some(ref istring) = item.value_str() {
-                let mut generic_map = def.generics.types.iter_enumerated()
-                                         .map(|(param, i, gen)| {
-                                               (gen.name.as_str().to_string(),
-                                                trait_ref.substs.types.get(param, i)
-                                                         .user_string(infcx.tcx))
-                                              }).collect::<HashMap<String, String>>();
-                generic_map.insert("Self".to_string(),
-                                   trait_ref.self_ty().user_string(infcx.tcx));
-                let parser = Parser::new(istring.get());
-                let mut errored = false;
-                let err: String = parser.filter_map(|p| {
-                    match p {
-                        Piece::String(s) => Some(s),
-                        Piece::NextArgument(a) => match a.position {
-                            Position::ArgumentNamed(s) => match generic_map.get(s) {
-                                Some(val) => Some(val.as_slice()),
-                                None => {
-                                    infcx.tcx.sess
-                                         .span_err(err_sp,
-                                                   format!("the #[rustc_on_unimplemented] \
-                                                            attribute on \
-                                                            trait definition for {} refers to \
-                                                            non-existent type parameter {}",
-                                                           trait_str, s)
-                                                   .as_slice());
-                                    errored = true;
-                                    None
-                                }
-                            },
-                            _ => {
-                                infcx.tcx.sess
-                                     .span_err(err_sp,
-                                               format!("the #[rustc_on_unimplemented] \
-                                                        attribute on \
-                                                        trait definition for {} must have named \
-                                                        format arguments, \
-                                                        eg `#[rustc_on_unimplemented = \
-                                                        \"foo {{T}}\"]`",
-                                                       trait_str).as_slice());
-                                errored = true;
-                                None
-                            }
-                        }
-                    }
-                }).collect();
-                // Report only if the format string checks out
-                if !errored {
-                    report = Some(err);
-                }
-            } else {
-                infcx.tcx.sess.span_err(err_sp,
-                                        format!("the #[rustc_on_unimplemented] attribute on \
-                                                 trait definition for {} must have a value, \
-                                                 eg `#[rustc_on_unimplemented = \"foo\"]`",
-                                                 trait_str).as_slice());
-            }
-            false
-        } else {
-            true
-        }
-    });
-    report
-}
-
 pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                                         obligation: &PredicateObligation<'tcx>,
                                         error: &SelectionError<'tcx>)
@@ -176,14 +94,6 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                                 "the trait `{}` is not implemented for the type `{}`",
                                 trait_ref.user_string(infcx.tcx),
                                 trait_ref.self_ty().user_string(infcx.tcx)).as_slice());
-                        // Check if it has a custom "#[rustc_on_unimplemented]" error message,
-                        // report with that message if it does
-                        let custom_note = report_on_unimplemented(infcx, &*trait_ref.0,
-                                                                  obligation.cause.span);
-                        if let Some(s) = custom_note {
-                           infcx.tcx.sess.span_note(obligation.cause.span,
-                                                    s.as_slice());
-                        }
                     }
                 }
 

branches/batch/src/librustc/middle/ty.rs

@@ -4702,7 +4702,7 @@ pub fn ty_sort_string<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> String {
         }
         ty_tup(ref tys) if tys.is_empty() => ::util::ppaux::ty_to_string(cx, ty),
 
-        ty_enum(id, _) => format!("enum {}", item_path_str(cx, id)),
+        ty_enum(id, _) => format!("enum `{}`", item_path_str(cx, id)),
         ty_uniq(_) => "box".to_string(),
         ty_vec(_, Some(n)) => format!("array of {} elements", n),
         ty_vec(_, None) => "slice".to_string(),
@@ -4714,7 +4714,7 @@ pub fn ty_sort_string<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> String {
             format!("trait {}", item_path_str(cx, inner.principal_def_id()))
         }
         ty_struct(id, _) => {
-            format!("struct {}", item_path_str(cx, id))
+            format!("struct `{}`", item_path_str(cx, id))
         }
         ty_unboxed_closure(..) => "closure".to_string(),
         ty_tup(_) => "tuple".to_string(),