address review comments

Author: arielb1

src/libcore/ops/try.rs

@@ -21,10 +21,11 @@
                                      (or another type that implements `{Try}`)")]
 #[cfg_attr(not(stage0),
            rustc_on_unimplemented(
-               on(all(direct, from_desugaring),
+               on(all(direct, from_desugaring="?"),
                   message="the `?` operator can only be used in a \
                            function that returns `Result` \
-                           (or another type that implements `{Try}`)")))]
+                           (or another type that implements `{Try}`)",
+                  label="cannot use the `?` operator in a function that returns `{Self}`")))]
 pub trait Try {
     /// The type of this value when viewed as successful.
     #[unstable(feature = "try_trait", issue = "42327")]

src/librustc/traits/error_reporting.rs

@@ -327,6 +327,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             .unwrap_or(trait_ref.def_id());
         let trait_ref = *trait_ref.skip_binder();
 
+        let s;
         let mut flags = vec![];
         let direct = match obligation.cause.code {
             ObligationCauseCode::BuiltinDerivedObligation(..) |
@@ -336,11 +337,13 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         if direct {
             // this is a "direct", user-specified, rather than derived,
             // obligation.
-            flags.push("direct");
+            flags.push(("direct", None));
         }
 
-        if let Some(_) = obligation.cause.span.compiler_desugaring_kind() {
-            flags.push("from_desugaring");
+        if let Some(k) = obligation.cause.span.compiler_desugaring_kind() {
+            s = k.as_symbol().as_str();
+            flags.push(("from_desugaring", None));
+            flags.push(("from_desugaring", Some(&*s)));
         }
 
         if let Ok(Some(command)) = OnUnimplementedDirective::of_item(

src/librustc/traits/on_unimplemented.rs

@@ -171,7 +171,7 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedDirective {
     pub fn evaluate(&self,
                     tcx: TyCtxt<'a, 'gcx, 'tcx>,
                     trait_ref: ty::TraitRef<'tcx>,
-                    options: &[&str])
+                    options: &[(&str, Option<&str>)])
                     -> OnUnimplementedNote
     {
         let mut message = None;
@@ -180,7 +180,11 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedDirective {
         for command in self.subcommands.iter().chain(Some(self)).rev() {
             if let Some(ref condition) = command.condition {
                 if !attr::eval_condition(condition, &tcx.sess.parse_sess, &mut |c| {
-                    options.iter().any(|o| c.check_name(o))
+                    options.contains(&(&c.name().as_str(),
+                                      match c.value_str().map(|s| s.as_str()) {
+                                          Some(ref s) => Some(s),
+                                          None => None
+                                      }))
                 }) {
                     debug!("evaluate: skipping {:?} due to condition", command);
                     continue

src/librustc_typeck/check/mod.rs

@@ -1218,8 +1218,7 @@ fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                     item: &hir::Item) {
     let item_def_id = tcx.hir.local_def_id(item.id);
     // an error would be reported if this fails.
-    let _ = traits::OnUnimplementedDirective::of_item(
-        tcx, trait_def_id, item_def_id);
+    let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
 }
 
 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,

src/test/ui/suggestions/try-operator-on-main.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(try_trait)]
+
 use std::ops::Try;
 
 fn main() {

src/test/ui/suggestions/try-operator-on-main.stderr

@@ -1,37 +1,22 @@
-error: use of unstable library feature 'try_trait' (see issue #42327)
-  --> $DIR/try-operator-on-main.rs:11:5
-   |
-11 | use std::ops::Try;
-   |     ^^^^^^^^^^^^^
-   |
-   = help: add #![feature(try_trait)] to the crate attributes to enable
-
-error: use of unstable library feature 'try_trait' (see issue #42327)
-  --> $DIR/try-operator-on-main.rs:19:25
-   |
-19 | fn try_trait_generic<T: Try>() {}
-   |                         ^^^
-   |
-   = help: add #![feature(try_trait)] to the crate attributes to enable
-
 error[E0277]: the `?` operator can only be used in a function that returns `Result` (or another type that implements `std::ops::Try`)
-  --> $DIR/try-operator-on-main.rs:14:5
+  --> $DIR/try-operator-on-main.rs:16:5
    |
-14 |     std::fs::File::open("foo")?;
+16 |     std::fs::File::open("foo")?;
    |     ---------------------------
    |     |
-   |     the trait `std::ops::Try` is not implemented for `()`
+   |     cannot use the `?` operator in a function that returns `()`
    |     in this macro invocation
    |
+   = help: the trait `std::ops::Try` is not implemented for `()`
    = note: required by `std::ops::Try::from_error`
 
 error[E0277]: the trait bound `(): std::ops::Try` is not satisfied
-  --> $DIR/try-operator-on-main.rs:16:5
+  --> $DIR/try-operator-on-main.rs:18:5
    |
-16 |     try_trait_generic::<()>();
+18 |     try_trait_generic::<()>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::ops::Try` is not implemented for `()`
    |
    = note: required by `try_trait_generic`
 
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors