Fill in suggestions Applicability according to @estebank

vi · vi · commit 2b7776094492 · 2018-09-17T03:20:08.000+03:00
Also fix some formatting along the way.
diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs
@@ -1250,6 +1250,11 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                                 let_span,
                                 "use a mutable reference instead",
                                 replace_str,
+                                // I believe this can be machine applicable,
+                                // but if there are multiple attempted uses of an immutable
+                                // reference, I don't know how rustfix handles it, it might
+                                // attempt fixing them multiple times.
+                                //                              @estebank
                                 Applicability::Unspecified,
                             );
                         }
@@ -1308,7 +1313,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                         "consider removing the `&mut`, as it is an \
                         immutable binding to a mutable reference",
                         snippet,
-                        Applicability::Unspecified,
+                        Applicability::MachineApplicable,
                     );
                 } else {
                     db.span_suggestion_with_applicability(
@@ -1345,7 +1350,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                                                    use the `move` keyword",
                                                    cmt_path_or_string),
                                          suggestion,
-                                         Applicability::Unspecified,
+                                         Applicability::MachineApplicable,
             )
             .emit();
         self.signal_error();
diff --git a/src/librustc_mir/borrow_check/move_errors.rs b/src/librustc_mir/borrow_check/move_errors.rs
@@ -426,7 +426,7 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> {
                 span,
                 &format!("consider removing the `{}`", to_remove),
                 suggestion,
-                Applicability::Unspecified,
+                Applicability::MachineApplicable,
             );
         }
     }
diff --git a/src/librustc_mir/borrow_check/mutability_errors.rs b/src/librustc_mir/borrow_check/mutability_errors.rs
@@ -232,7 +232,7 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> {
                     local_decl.source_info.span,
                     "consider changing this to be mutable",
                     format!("mut {}", local_decl.name.unwrap()),
-                    Applicability::Unspecified,
+                    Applicability::MachineApplicable,
                 );
             }
 
@@ -263,7 +263,7 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> {
                             upvar_ident.span,
                             "consider changing this to be mutable",
                             format!("mut {}", upvar_ident.name),
-                            Applicability::Unspecified,
+                            Applicability::MachineApplicable,
                         );
                     }
                 }
@@ -358,7 +358,7 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> {
                         err_help_span,
                         &format!("consider changing this to be a mutable {}", pointer_desc),
                         suggested_code,
-                        Applicability::Unspecified,
+                        Applicability::MachineApplicable,
                     );
                 }
 
diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs
@@ -184,7 +184,7 @@ impl<'a> AstValidator<'a> {
             if let Ok(snippet) = self.session.source_map().span_to_snippet(span) {
                 err.span_suggestion_with_applicability(
                     span, "consider adding parentheses", format!("({})", snippet),
-                    Applicability::Unspecified,
+                    Applicability::MachineApplicable,
                 );
             }
 
diff --git a/src/librustc_passes/loops.rs b/src/librustc_passes/loops.rs
@@ -147,7 +147,7 @@ impl<'a, 'hir> Visitor<'hir> for CheckLoopVisitor<'a, 'hir> {
                                                            without a value inside this `{}` loop",
                                                           kind.name()),
                                                  "break".to_string(),
-                                                 Applicability::Unspecified,
+                                                 Applicability::MaybeIncorrect,
                                 )
                                 .emit();
                         }
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
@@ -3303,7 +3303,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
                                                       sp,
                                                       "did you mean to use `;` here instead?",
                                                       ";".to_string(),
-                                                      Applicability::Unspecified,
+                                                      Applicability::MaybeIncorrect,
                                                       );
                         }
                         break;
diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs
@@ -332,7 +332,7 @@ impl<'a, 'gcx, 'tcx> CastCheck<'tcx> {
                             err.span_suggestion_with_applicability(self.cast_span,
                                                 "try casting to a reference instead",
                                                 format!("&{}{}", mtstr, s),
-                                                Applicability::Unspecified,
+                                                Applicability::MachineApplicable,
                                                 );
                         }
                         Err(_) => {
@@ -353,7 +353,7 @@ impl<'a, 'gcx, 'tcx> CastCheck<'tcx> {
                         err.span_suggestion_with_applicability(self.cast_span,
                                             "try casting to a `Box` instead",
                                             format!("Box<{}>", s),
-                                            Applicability::Unspecified,
+                                            Applicability::MachineApplicable,
                                             );
                     }
                     Err(_) => span_help!(err, self.cast_span, "did you mean `Box<{}>`?", tstr),
diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs
@@ -326,7 +326,7 @@ fn compare_predicate_entailment<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                             impl_err_span,
                             "consider change the type to match the mutability in trait",
                             format!("{}", trait_err_str),
-                            Applicability::Unspecified,
+                            Applicability::MachineApplicable,
                         );
                     }
                 }
@@ -811,7 +811,7 @@ fn compare_synthetic_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                 // of the generics, but it works for the common case
                                 (generics_span, new_generics),
                             ],
-                            Applicability::Unspecified,
+                            Applicability::MaybeIncorrect,
                         );
                         Some(())
                     })();
@@ -881,7 +881,7 @@ fn compare_synthetic_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                 // replace param usage with `impl Trait`
                                 (span, format!("impl {}", bounds)),
                             ],
-                            Applicability::Unspecified,
+                            Applicability::MaybeIncorrect,
                         );
                         Some(())
                     })();
diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs
@@ -135,7 +135,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                 err.span_suggestions_with_applicability(expr.span,
                                      "try using a variant of the expected type",
                                      suggestions,
-                                     Applicability::Unspecified,
+                                     Applicability::MaybeIncorrect,
                                      );
             }
         }
diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs
@@ -258,7 +258,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                                     format!("{}_{}",
                                                             snippet,
                                                             concrete_type),
-                                                    Applicability::Unspecified,
+                                                    Applicability::MaybeIncorrect,
                                                     );
                             }
                             hir::ExprKind::Path(ref qpath) => {  // local binding
@@ -290,7 +290,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                                         .unwrap_or(span)),
                                                     &msg,
                                                     format!("{}: {}", snippet, concrete_type),
-                                                    Applicability::Unspecified,
+                                                    Applicability::MaybeIncorrect,
                                                 );
                                             }
                                             _ => {
@@ -519,8 +519,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                 format!("use {};\n{}", self.tcx.item_path_str(*did), additional_newline)
             }).collect();
 
-            err.span_suggestions_with_applicability(span, &msg, path_strings,
-                                                    Applicability::Unspecified);
+            err.span_suggestions_with_applicability(
+                                                    span,
+                                                    &msg,
+                                                    path_strings,
+                                                    Applicability::MaybeIncorrect,
+                                                    );
         } else {
             let limit = if candidates.len() == 5 { 5 } else { 4 };
             for (i, trait_did) in candidates.iter().take(limit).enumerate() {
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -3348,8 +3348,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                         let base = self.tcx.hir.node_to_pretty_string(base.id);
                         let msg = format!("`{}` is a native pointer; try dereferencing it", base);
                         let suggestion = format!("(*{}).{}", base, field);
-                        err.span_suggestion_with_applicability(field.span, &msg, suggestion,
-                                                               Applicability::Unspecified);
+                        err.span_suggestion_with_applicability(
+                                                               field.span,
+                                                               &msg,
+                                                               suggestion,
+                                                               Applicability::MaybeIncorrect,
+                                                               );
                     }
                     _ => {}
                 }
@@ -4717,8 +4721,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         found: Ty<'tcx>,
     ) {
         if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
-            err.span_suggestion_with_applicability(sp, msg, suggestion,
-                                                   Applicability::Unspecified);
+            err.span_suggestion_with_applicability(
+                                                   sp,
+                                                   msg,
+                                                   suggestion,
+                                                   Applicability::MachineApplicable,
+                                                   );
         } else if !self.check_for_cast(err, expr, found, expected) {
             let methods = self.get_conversion_methods(expr.span, expected, found);
             if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
@@ -4748,10 +4756,11 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                         }
                     }) .collect::<Vec<_>>();
                 if !suggestions.is_empty() {
-                    err.span_suggestions_with_applicability(expr.span,
+                    err.span_suggestions_with_applicability(
+                                                            expr.span,
                                                             "try using a conversion method",
                                                             suggestions,
-                                                            Applicability::Unspecified,
+                                                            Applicability::MaybeIncorrect,
                                                             );
                 }
             }
diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs
@@ -444,10 +444,11 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                     err.span_label(expr.span,
                                    "`+` can't be used to concatenate two `&str` strings");
                     match source_map.span_to_snippet(lhs_expr.span) {
-                        Ok(lstring) => err.span_suggestion_with_applicability(lhs_expr.span,
+                        Ok(lstring) => err.span_suggestion_with_applicability(
+                                                           lhs_expr.span,
                                                            msg,
                                                            format!("{}.to_owned()", lstring),
-                                                           Applicability::Unspecified,
+                                                           Applicability::MachineApplicable,
                                                            ),
                         _ => err.help(msg),
                     };
@@ -464,11 +465,13 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                     is_assign,
                 ) {
                     (Ok(l), Ok(r), false) => {
-                        err.multipart_suggestion_with_applicability(msg, vec![
-                            (lhs_expr.span, format!("{}.to_owned()", l)),
-                            (rhs_expr.span, format!("&{}", r)),
-                        ],
-                        Applicability::Unspecified,
+                        err.multipart_suggestion_with_applicability(
+                                        msg,
+                                        vec![
+                                            (lhs_expr.span, format!("{}.to_owned()", l)),
+                                            (rhs_expr.span, format!("&{}", r)),
+                                        ],
+                                        Applicability::MachineApplicable,
                         );
                     }
                     _ => {
diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
@@ -124,10 +124,11 @@ impl<'a> StripUnconfigured<'a> {
             let error = |span, msg, suggestion: &str| {
                 let mut err = self.sess.span_diagnostic.struct_span_err(span, msg);
                 if !suggestion.is_empty() {
-                    err.span_suggestion_with_applicability(span,
+                    err.span_suggestion_with_applicability(
+                                                           span,
                                                            "expected syntax is",
                                                            suggestion.into(),
-                                                           Applicability::Unspecified,
+                                                           Applicability::MaybeIncorrect,
                                                            );
                 }
                 err.emit();
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
@@ -189,10 +189,10 @@ fn generic_extension<'cx>(cx: &'cx mut ExtCtxt,
                         err.note("you might be missing a comma");
                     } else {
                         err.span_suggestion_short_with_applicability(
-                            comma_span,
-                            "missing comma here",
-                            ", ".to_string(),
-                            Applicability::Unspecified,
+                                                comma_span,
+                                                "missing comma here",
+                                                ", ".to_string(),
+                                                Applicability::MachineApplicable,
                         );
                     }
                 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -3882,11 +3882,12 @@ impl<'a> Parser<'a> {
                 if self.token == token::CloseDelim(token::Brace) {
                     // If the struct looks otherwise well formed, recover and continue.
                     if let Some(sp) = comma_sp {
-                        err.span_suggestion_short_with_applicability(sp,
-                                                                     "remove this comma",
-                                                                     String::new(),
-                                                                     Applicability::Unspecified,
-                                                                     );
+                        err.span_suggestion_short_with_applicability(
+                                                                 sp,
+                                                                 "remove this comma",
+                                                                 String::new(),
+                                                                 Applicability::MachineApplicable,
+                                                                 );
                     }
                     err.emit();
                     break;
diff --git a/src/libsyntax_ext/format.rs b/src/libsyntax_ext/format.rs
@@ -997,9 +997,9 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
                     }
                     if suggestions.len() > 0 {
                         diag.multipart_suggestion_with_applicability(
-                            "format specifiers use curly braces",
-                            suggestions,
-                            Applicability::Unspecified,
+                                                    "format specifiers use curly braces",
+                                                    suggestions,
+                                                    Applicability::MachineApplicable,
                         );
                     }
                 }};

Original file line number	Diff line number	Diff line change
`@@ -426,7 +426,7 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> {`
`426`	`426`	`span,`
`427`	`427`	&format!("consider removing the `{}`", to_remove),
`428`	`428`	`suggestion,`
`429`		`- Applicability::Unspecified,`
	`429`	`+ Applicability::MachineApplicable,`
`430`	`430`	`);`
`431`	`431`	`}`
`432`	`432`	`}`
Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> {`
`232`	`232`	`local_decl.source_info.span,`
`233`	`233`	`"consider changing this to be mutable",`
`234`	`234`	`format!("mut {}", local_decl.name.unwrap()),`
`235`		`- Applicability::Unspecified,`
	`235`	`+ Applicability::MachineApplicable,`
`236`	`236`	`);`
`237`	`237`	`}`
`238`	`238`
`@@ -263,7 +263,7 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> {`
`263`	`263`	`upvar_ident.span,`
`264`	`264`	`"consider changing this to be mutable",`
`265`	`265`	`format!("mut {}", upvar_ident.name),`
`266`		`- Applicability::Unspecified,`
	`266`	`+ Applicability::MachineApplicable,`
`267`	`267`	`);`
`268`	`268`	`}`
`269`	`269`	`}`
`@@ -358,7 +358,7 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> {`
`358`	`358`	`err_help_span,`
`359`	`359`	`&format!("consider changing this to be a mutable {}", pointer_desc),`
`360`	`360`	`suggested_code,`
`361`		`- Applicability::Unspecified,`
	`361`	`+ Applicability::MachineApplicable,`
`362`	`362`	`);`
`363`	`363`	`}`
`364`	`364`
Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ impl<'a> AstValidator<'a> {`
`184`	`184`	`if let Ok(snippet) = self.session.source_map().span_to_snippet(span) {`
`185`	`185`	`err.span_suggestion_with_applicability(`
`186`	`186`	`span, "consider adding parentheses", format!("({})", snippet),`
`187`		`- Applicability::Unspecified,`
	`187`	`+ Applicability::MachineApplicable,`
`188`	`188`	`);`
`189`	`189`	`}`
`190`	`190`
Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ impl<'a, 'hir> Visitor<'hir> for CheckLoopVisitor<'a, 'hir> {`
`147`	`147`	without a value inside this `{}` loop",
`148`	`148`	`kind.name()),`
`149`	`149`	`"break".to_string(),`
`150`		`- Applicability::Unspecified,`
	`150`	`+ Applicability::MaybeIncorrect,`
`151`	`151`	`)`
`152`	`152`	`.emit();`
`153`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3303,7 +3303,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {`
`3303`	`3303`	`sp,`
`3304`	`3304`	"did you mean to use `;` here instead?",
`3305`	`3305`	`";".to_string(),`
`3306`		`- Applicability::Unspecified,`
	`3306`	`+ Applicability::MaybeIncorrect,`
`3307`	`3307`	`);`
`3308`	`3308`	`}`
`3309`	`3309`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {`
`135`	`135`	`err.span_suggestions_with_applicability(expr.span,`
`136`	`136`	`"try using a variant of the expected type",`
`137`	`137`	`suggestions,`
`138`		`- Applicability::Unspecified,`
	`138`	`+ Applicability::MaybeIncorrect,`
`139`	`139`	`);`
`140`	`140`	`}`
`141`	`141`	`}`