From 1f421d645633f600e85ecec60a56ac5b4c19335c Mon Sep 17 00:00:00 2001 From: Joseph Post Date: Sat, 25 Aug 2018 22:47:46 -0500 Subject: [PATCH] call span_suggestion with applicability --- src/librustc_resolve/lib.rs | 62 ++++++++++++++++-------- src/librustc_typeck/structured_errors.rs | 11 +++-- src/libsyntax/parse/parser.rs | 14 +++++- 3 files changed, 60 insertions(+), 27 deletions(-) diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 264f5c0113581..8ef5144501972 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -69,7 +69,7 @@ use syntax::feature_gate::{feature_err, GateIssue}; use syntax::ptr::P; use syntax_pos::{Span, DUMMY_SP, MultiSpan}; -use errors::{DiagnosticBuilder, DiagnosticId}; +use errors::{Applicability, DiagnosticBuilder, DiagnosticId}; use std::cell::{Cell, RefCell}; use std::cmp; @@ -220,9 +220,12 @@ fn resolve_struct_error<'sess, 'a>(resolver: &'sess Resolver, let sugg_msg = "try using a local type parameter instead"; if let Some((sugg_span, new_snippet)) = cm.generate_local_type_param_snippet(span) { // Suggest the modification to the user - err.span_suggestion(sugg_span, - sugg_msg, - new_snippet); + err.span_suggestion_with_applicability( + sugg_span, + sugg_msg, + new_snippet, + Applicability::MachineApplicable, + ); } else if let Some(sp) = cm.generate_fn_name_span(span) { err.span_label(sp, "try adding a local type parameter in this method instead"); } else { @@ -2998,8 +3001,12 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { enum_path); err.help(&msg); } else { - err.span_suggestion(span, "you can try using the variant's enum", - enum_path); + err.span_suggestion_with_applicability( + span, + "you can try using the variant's enum", + enum_path, + Applicability::MachineApplicable, + ); } } } @@ -3008,20 +3015,32 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { let self_is_available = this.self_value_is_available(path[0].span, span); match candidate { AssocSuggestion::Field => { - err.span_suggestion(span, "try", - format!("self.{}", path_str)); + err.span_suggestion_with_applicability( + span, + "try", + format!("self.{}", path_str), + Applicability::MachineApplicable, + ); if !self_is_available { err.span_label(span, format!("`self` value is only available in \ methods with `self` parameter")); } } AssocSuggestion::MethodWithSelf if self_is_available => { - err.span_suggestion(span, "try", - format!("self.{}", path_str)); + err.span_suggestion_with_applicability( + span, + "try", + format!("self.{}", path_str), + Applicability::MachineApplicable, + ); } AssocSuggestion::MethodWithSelf | AssocSuggestion::AssocItem => { - err.span_suggestion(span, "try", - format!("Self::{}", path_str)); + err.span_suggestion_with_applicability( + span, + "try", + format!("Self::{}", path_str), + Applicability::MachineApplicable, + ); } } return (err, candidates); @@ -4617,15 +4636,16 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { format!("other_{}", name) }; - err.span_suggestion(binding.span, - rename_msg, - if snippet.ends_with(';') { - format!("{} as {};", - &snippet[..snippet.len()-1], - suggested_name) - } else { - format!("{} as {}", snippet, suggested_name) - }); + err.span_suggestion_with_applicability( + binding.span, + rename_msg, + if snippet.ends_with(';') { + format!("{} as {};", &snippet[..snippet.len() - 1], suggested_name) + } else { + format!("{} as {}", snippet, suggested_name) + }, + Applicability::MachineApplicable, + ); } else { err.span_label(binding.span, rename_msg); } diff --git a/src/librustc_typeck/structured_errors.rs b/src/librustc_typeck/structured_errors.rs index ffd9da8c8b95c..12863cc66a053 100644 --- a/src/librustc_typeck/structured_errors.rs +++ b/src/librustc_typeck/structured_errors.rs @@ -10,7 +10,7 @@ use rustc::session::Session; use syntax_pos::Span; -use errors::{DiagnosticId, DiagnosticBuilder}; +use errors::{Applicability, DiagnosticId, DiagnosticBuilder}; use rustc::ty::{Ty, TypeFoldable}; pub trait StructuredDiagnostic<'tcx> { @@ -73,9 +73,12 @@ impl<'tcx> StructuredDiagnostic<'tcx> for VariadicError<'tcx> { ) }; if let Ok(snippet) = self.sess.source_map().span_to_snippet(self.span) { - err.span_suggestion(self.span, - &format!("cast the value to `{}`", self.cast_ty), - format!("{} as {}", snippet, self.cast_ty)); + err.span_suggestion_with_applicability( + self.span, + &format!("cast the value to `{}`", self.cast_ty), + format!("{} as {}", snippet, self.cast_ty), + Applicability::MachineApplicable, + ); } else { err.help(&format!("cast the value to `{}`", self.cast_ty)); } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 725360b842d43..a9bb013698e97 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -786,7 +786,12 @@ impl<'a> Parser<'a> { } else { err.span_label(self.span, "expected identifier"); if self.token == token::Comma && self.look_ahead(1, |t| t.is_ident()) { - err.span_suggestion(self.span, "remove this comma", String::new()); + err.span_suggestion_with_applicability( + self.span, + "remove this comma", + String::new(), + Applicability::MachineApplicable, + ); } } err @@ -6077,7 +6082,12 @@ impl<'a> Parser<'a> { self.this_token_to_string())); if self.token.is_ident() { // This is likely another field; emit the diagnostic and keep going - err.span_suggestion(sp, "try adding a comma", ",".into()); + err.span_suggestion_with_applicability( + sp, + "try adding a comma", + ",".into(), + Applicability::MachineApplicable, + ); err.emit(); } else { return Err(err)