//! macro-expanded files, but we need to present them to the users in terms of
//! original files. So we need to map the ranges.
-mod fixes;
-mod field_shorthand;
+mod break_outside_of_loop;
+mod inactive_code;
+mod incorrect_case;
+mod macro_error;
+mod mismatched_arg_count;
+mod missing_fields;
+mod missing_match_arms;
+mod missing_ok_or_some_in_tail_expr;
+mod missing_unsafe;
+mod no_such_field;
+mod remove_this_semicolon;
+mod replace_filter_map_next_with_find_map;
+mod unimplemented_builtin_macro;
mod unlinked_file;
+mod unresolved_extern_crate;
+mod unresolved_import;
+mod unresolved_macro_call;
+mod unresolved_module;
+mod unresolved_proc_macro;
+
+mod field_shorthand;
use std::cell::RefCell;
use hir::{
- db::AstDatabase,
- diagnostics::{Diagnostic as _, DiagnosticCode, DiagnosticSinkBuilder},
- InFile, Semantics,
+ diagnostics::{AnyDiagnostic, DiagnosticCode, DiagnosticSinkBuilder},
+ Semantics,
};
use ide_assists::AssistResolveStrategy;
use ide_db::{base_db::SourceDatabase, RootDatabase};
use rustc_hash::FxHashSet;
use syntax::{
ast::{self, AstNode},
- SyntaxNode, SyntaxNodePtr, TextRange, TextSize,
+ SyntaxNode, TextRange,
};
use text_edit::TextEdit;
use unlinked_file::UnlinkedFile;
use crate::{Assist, AssistId, AssistKind, FileId, Label, SourceChange};
-use self::fixes::DiagnosticWithFix;
-
#[derive(Debug)]
pub struct Diagnostic {
// pub name: Option<String>,
pub message: String,
pub range: TextRange,
pub severity: Severity,
- pub fix: Option<Assist>,
+ pub fixes: Option<Vec<Assist>>,
pub unused: bool,
pub code: Option<DiagnosticCode>,
+ pub experimental: bool,
}
impl Diagnostic {
+ fn new(code: &'static str, message: impl Into<String>, range: TextRange) -> Diagnostic {
+ let message = message.into();
+ let code = Some(DiagnosticCode(code));
+ Self {
+ message,
+ range,
+ severity: Severity::Error,
+ fixes: None,
+ unused: false,
+ code,
+ experimental: false,
+ }
+ }
+
+ fn experimental(mut self) -> Diagnostic {
+ self.experimental = true;
+ self
+ }
+
+ fn severity(mut self, severity: Severity) -> Diagnostic {
+ self.severity = severity;
+ self
+ }
+
fn error(range: TextRange, message: String) -> Self {
- Self { message, range, severity: Severity::Error, fix: None, unused: false, code: None }
+ Self {
+ message,
+ range,
+ severity: Severity::Error,
+ fixes: None,
+ unused: false,
+ code: None,
+ experimental: false,
+ }
}
fn hint(range: TextRange, message: String) -> Self {
message,
range,
severity: Severity::WeakWarning,
- fix: None,
+ fixes: None,
unused: false,
code: None,
+ experimental: false,
}
}
- fn with_fix(self, fix: Option<Assist>) -> Self {
- Self { fix, ..self }
+ fn with_fixes(self, fixes: Option<Vec<Assist>>) -> Self {
+ Self { fixes, ..self }
}
fn with_unused(self, unused: bool) -> Self {
pub disabled: FxHashSet<String>,
}
+struct DiagnosticsContext<'a> {
+ config: &'a DiagnosticsConfig,
+ sema: Semantics<'a, RootDatabase>,
+ resolve: &'a AssistResolveStrategy,
+}
+
pub(crate) fn diagnostics(
db: &RootDatabase,
config: &DiagnosticsConfig,
}
let res = RefCell::new(res);
let sink_builder = DiagnosticSinkBuilder::new()
- .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
- res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
- })
- .on::<hir::diagnostics::MissingFields, _>(|d| {
- res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
- })
- .on::<hir::diagnostics::MissingOkOrSomeInTailExpr, _>(|d| {
- res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
- })
- .on::<hir::diagnostics::NoSuchField, _>(|d| {
- res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
- })
- .on::<hir::diagnostics::RemoveThisSemicolon, _>(|d| {
- res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
- })
- .on::<hir::diagnostics::IncorrectCase, _>(|d| {
- res.borrow_mut().push(warning_with_fix(d, &sema, resolve));
- })
- .on::<hir::diagnostics::ReplaceFilterMapNextWithFindMap, _>(|d| {
- res.borrow_mut().push(warning_with_fix(d, &sema, resolve));
- })
- .on::<hir::diagnostics::InactiveCode, _>(|d| {
- // If there's inactive code somewhere in a macro, don't propagate to the call-site.
- if d.display_source().file_id.expansion_info(db).is_some() {
- return;
- }
-
- // Override severity and mark as unused.
- res.borrow_mut().push(
- Diagnostic::hint(
- sema.diagnostics_display_range(d.display_source()).range,
- d.message(),
- )
- .with_unused(true)
- .with_code(Some(d.code())),
- );
- })
- .on::<UnlinkedFile, _>(|d| {
- // Limit diagnostic to the first few characters in the file. This matches how VS Code
- // renders it with the full span, but on other editors, and is less invasive.
- let range = sema.diagnostics_display_range(d.display_source()).range;
- let range = range.intersect(TextRange::up_to(TextSize::of("..."))).unwrap_or(range);
-
- // Override severity and mark as unused.
- res.borrow_mut().push(
- Diagnostic::hint(range, d.message())
- .with_fix(d.fix(&sema, resolve))
- .with_code(Some(d.code())),
- );
- })
- .on::<hir::diagnostics::UnresolvedProcMacro, _>(|d| {
- // Use more accurate position if available.
- let display_range = d
- .precise_location
- .unwrap_or_else(|| sema.diagnostics_display_range(d.display_source()).range);
-
- // FIXME: it would be nice to tell the user whether proc macros are currently disabled
- res.borrow_mut()
- .push(Diagnostic::hint(display_range, d.message()).with_code(Some(d.code())));
- })
- .on::<hir::diagnostics::UnresolvedMacroCall, _>(|d| {
- let last_path_segment = sema.db.parse_or_expand(d.file).and_then(|root| {
- d.node
- .to_node(&root)
- .path()
- .and_then(|it| it.segment())
- .and_then(|it| it.name_ref())
- .map(|it| InFile::new(d.file, SyntaxNodePtr::new(it.syntax())))
- });
- let diagnostics = last_path_segment.unwrap_or_else(|| d.display_source());
- let display_range = sema.diagnostics_display_range(diagnostics).range;
- res.borrow_mut()
- .push(Diagnostic::error(display_range, d.message()).with_code(Some(d.code())));
- })
// Only collect experimental diagnostics when they're enabled.
.filter(|diag| !(diag.is_experimental() && config.disable_experimental))
.filter(|diag| !config.disabled.contains(diag.code().as_str()));
);
});
- match sema.to_module_def(file_id) {
- Some(m) => m.diagnostics(db, &mut sink),
- None => {
- sink.push(UnlinkedFile { file_id, node: SyntaxNodePtr::new(&parse.tree().syntax()) });
- }
+ let mut diags = Vec::new();
+ let module = sema.to_module_def(file_id);
+ if let Some(m) = module {
+ diags = m.diagnostics(db, &mut sink)
}
drop(sink);
- res.into_inner()
-}
-fn diagnostic_with_fix<D: DiagnosticWithFix>(
- d: &D,
- sema: &Semantics<RootDatabase>,
- resolve: &AssistResolveStrategy,
-) -> Diagnostic {
- Diagnostic::error(sema.diagnostics_display_range(d.display_source()).range, d.message())
- .with_fix(d.fix(&sema, resolve))
- .with_code(Some(d.code()))
-}
+ let mut res = res.into_inner();
-fn warning_with_fix<D: DiagnosticWithFix>(
- d: &D,
- sema: &Semantics<RootDatabase>,
- resolve: &AssistResolveStrategy,
-) -> Diagnostic {
- Diagnostic::hint(sema.diagnostics_display_range(d.display_source()).range, d.message())
- .with_fix(d.fix(&sema, resolve))
- .with_code(Some(d.code()))
+ let ctx = DiagnosticsContext { config, sema, resolve };
+ if module.is_none() {
+ let d = UnlinkedFile { file: file_id };
+ let d = unlinked_file::unlinked_file(&ctx, &d);
+ res.push(d)
+ }
+
+ for diag in diags {
+ #[rustfmt::skip]
+ let d = match diag {
+ AnyDiagnostic::BreakOutsideOfLoop(d) => break_outside_of_loop::break_outside_of_loop(&ctx, &d),
+ AnyDiagnostic::IncorrectCase(d) => incorrect_case::incorrect_case(&ctx, &d),
+ AnyDiagnostic::MacroError(d) => macro_error::macro_error(&ctx, &d),
+ AnyDiagnostic::MismatchedArgCount(d) => mismatched_arg_count::mismatched_arg_count(&ctx, &d),
+ AnyDiagnostic::MissingFields(d) => missing_fields::missing_fields(&ctx, &d),
+ AnyDiagnostic::MissingMatchArms(d) => missing_match_arms::missing_match_arms(&ctx, &d),
+ AnyDiagnostic::MissingOkOrSomeInTailExpr(d) => missing_ok_or_some_in_tail_expr::missing_ok_or_some_in_tail_expr(&ctx, &d),
+ AnyDiagnostic::MissingUnsafe(d) => missing_unsafe::missing_unsafe(&ctx, &d),
+ AnyDiagnostic::NoSuchField(d) => no_such_field::no_such_field(&ctx, &d),
+ AnyDiagnostic::RemoveThisSemicolon(d) => remove_this_semicolon::remove_this_semicolon(&ctx, &d),
+ AnyDiagnostic::ReplaceFilterMapNextWithFindMap(d) => replace_filter_map_next_with_find_map::replace_filter_map_next_with_find_map(&ctx, &d),
+ AnyDiagnostic::UnimplementedBuiltinMacro(d) => unimplemented_builtin_macro::unimplemented_builtin_macro(&ctx, &d),
+ AnyDiagnostic::UnresolvedExternCrate(d) => unresolved_extern_crate::unresolved_extern_crate(&ctx, &d),
+ AnyDiagnostic::UnresolvedImport(d) => unresolved_import::unresolved_import(&ctx, &d),
+ AnyDiagnostic::UnresolvedMacroCall(d) => unresolved_macro_call::unresolved_macro_call(&ctx, &d),
+ AnyDiagnostic::UnresolvedModule(d) => unresolved_module::unresolved_module(&ctx, &d),
+ AnyDiagnostic::UnresolvedProcMacro(d) => unresolved_proc_macro::unresolved_proc_macro(&ctx, &d),
+
+ AnyDiagnostic::InactiveCode(d) => match inactive_code::inactive_code(&ctx, &d) {
+ Some(it) => it,
+ None => continue,
+ }
+ };
+ res.push(d)
+ }
+
+ res.retain(|d| {
+ if let Some(code) = d.code {
+ if ctx.config.disabled.contains(code.as_str()) {
+ return false;
+ }
+ }
+ if ctx.config.disable_experimental && d.experimental {
+ return false;
+ }
+ true
+ });
+
+ res
}
fn check_unnecessary_braces_in_use_statement(
acc.push(
Diagnostic::hint(use_range, "Unnecessary braces in use statement".to_string())
- .with_fix(Some(fix(
+ .with_fixes(Some(vec![fix(
"remove_braces",
"Remove unnecessary braces",
SourceChange::from_text_edit(file_id, edit),
use_range,
- ))),
+ )])),
);
}
#[cfg(test)]
mod tests {
- use expect_test::{expect, Expect};
+ use expect_test::Expect;
use ide_assists::AssistResolveStrategy;
use stdx::trim_indent;
- use test_utils::assert_eq_text;
+ use test_utils::{assert_eq_text, extract_annotations};
use crate::{fixture, DiagnosticsConfig};
/// Takes a multi-file input fixture with annotated cursor positions,
/// and checks that:
/// * a diagnostic is produced
- /// * this diagnostic fix trigger range touches the input cursor position
+ /// * the first diagnostic fix trigger range touches the input cursor position
/// * that the contents of the file containing the cursor match `after` after the diagnostic fix is applied
+ #[track_caller]
pub(crate) fn check_fix(ra_fixture_before: &str, ra_fixture_after: &str) {
+ check_nth_fix(0, ra_fixture_before, ra_fixture_after);
+ }
+ /// Takes a multi-file input fixture with annotated cursor positions,
+ /// and checks that:
+ /// * a diagnostic is produced
+ /// * every diagnostic fixes trigger range touches the input cursor position
+ /// * that the contents of the file containing the cursor match `after` after each diagnostic fix is applied
+ pub(crate) fn check_fixes(ra_fixture_before: &str, ra_fixtures_after: Vec<&str>) {
+ for (i, ra_fixture_after) in ra_fixtures_after.iter().enumerate() {
+ check_nth_fix(i, ra_fixture_before, ra_fixture_after)
+ }
+ }
+
+ #[track_caller]
+ fn check_nth_fix(nth: usize, ra_fixture_before: &str, ra_fixture_after: &str) {
let after = trim_indent(ra_fixture_after);
let (analysis, file_position) = fixture::position(ra_fixture_before);
.unwrap()
.pop()
.unwrap();
- let fix = diagnostic.fix.unwrap();
+ let fix = &diagnostic.fixes.unwrap()[nth];
let actual = {
- let source_change = fix.source_change.unwrap();
+ let source_change = fix.source_change.as_ref().unwrap();
let file_id = *source_change.source_file_edits.keys().next().unwrap();
let mut actual = analysis.file_text(file_id).unwrap().to_string();
}
/// Checks that there's a diagnostic *without* fix at `$0`.
- fn check_no_fix(ra_fixture: &str) {
+ pub(crate) fn check_no_fix(ra_fixture: &str) {
let (analysis, file_position) = fixture::position(ra_fixture);
let diagnostic = analysis
.diagnostics(
.unwrap()
.pop()
.unwrap();
- assert!(diagnostic.fix.is_none(), "got a fix when none was expected: {:?}", diagnostic);
- }
-
- /// Takes a multi-file input fixture with annotated cursor position and checks that no diagnostics
- /// apply to the file containing the cursor.
- pub(crate) fn check_no_diagnostics(ra_fixture: &str) {
- let (analysis, files) = fixture::files(ra_fixture);
- let diagnostics = files
- .into_iter()
- .flat_map(|file_id| {
- analysis
- .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id)
- .unwrap()
- })
- .collect::<Vec<_>>();
- assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics);
+ assert!(diagnostic.fixes.is_none(), "got a fix when none was expected: {:?}", diagnostic);
}
pub(crate) fn check_expect(ra_fixture: &str, expect: Expect) {
expect.assert_debug_eq(&diagnostics)
}
- #[test]
- fn test_unresolved_macro_range() {
- check_expect(
- r#"foo::bar!(92);"#,
- expect![[r#"
- [
- Diagnostic {
- message: "unresolved macro `foo::bar!`",
- range: 5..8,
- severity: Error,
- fix: None,
- unused: false,
- code: Some(
- DiagnosticCode(
- "unresolved-macro-call",
- ),
- ),
- },
- ]
- "#]],
- );
+ #[track_caller]
+ pub(crate) fn check_diagnostics(ra_fixture: &str) {
+ let mut config = DiagnosticsConfig::default();
+ config.disabled.insert("inactive-code".to_string());
+ check_diagnostics_with_config(config, ra_fixture)
}
- #[test]
- fn range_mapping_out_of_macros() {
- // FIXME: this is very wrong, but somewhat tricky to fix.
- check_fix(
- r#"
-fn some() {}
-fn items() {}
-fn here() {}
-
-macro_rules! id { ($($tt:tt)*) => { $($tt)*}; }
-
-fn main() {
- let _x = id![Foo { a: $042 }];
-}
-
-pub struct Foo { pub a: i32, pub b: i32 }
-"#,
- r#"
-fn some(, b: () ) {}
-fn items() {}
-fn here() {}
-
-macro_rules! id { ($($tt:tt)*) => { $($tt)*}; }
-
-fn main() {
- let _x = id![Foo { a: 42 }];
-}
-
-pub struct Foo { pub a: i32, pub b: i32 }
-"#,
- );
+ #[track_caller]
+ pub(crate) fn check_diagnostics_with_config(config: DiagnosticsConfig, ra_fixture: &str) {
+ let (analysis, files) = fixture::files(ra_fixture);
+ for file_id in files {
+ let diagnostics =
+ analysis.diagnostics(&config, AssistResolveStrategy::All, file_id).unwrap();
+
+ let expected = extract_annotations(&*analysis.file_text(file_id).unwrap());
+ let mut actual =
+ diagnostics.into_iter().map(|d| (d.range, d.message)).collect::<Vec<_>>();
+ actual.sort_by_key(|(range, _)| range.start());
+ assert_eq!(expected, actual);
+ }
}
#[test]
fn test_check_unnecessary_braces_in_use_statement() {
- check_no_diagnostics(
+ check_diagnostics(
r#"
use a;
use a::{c, d::e};
}
"#,
);
- check_no_diagnostics(
+ check_diagnostics(
r#"
use a;
use a::{
}
#[test]
- fn unlinked_file_prepend_first_item() {
- cov_mark::check!(unlinked_file_prepend_before_first_item);
- check_fix(
- r#"
-//- /main.rs
-fn f() {}
-//- /foo.rs
-$0
-"#,
- r#"
-mod foo;
-
-fn f() {}
-"#,
- );
- }
-
- #[test]
- fn unlinked_file_append_mod() {
- cov_mark::check!(unlinked_file_append_to_existing_mods);
- check_fix(
- r#"
-//- /main.rs
-//! Comment on top
-
-mod preexisting;
-
-mod preexisting2;
-
-struct S;
-
-mod preexisting_bottom;)
-//- /foo.rs
-$0
-"#,
- r#"
-//! Comment on top
-
-mod preexisting;
-
-mod preexisting2;
-mod foo;
-
-struct S;
-
-mod preexisting_bottom;)
-"#,
- );
- }
-
- #[test]
- fn unlinked_file_insert_in_empty_file() {
- cov_mark::check!(unlinked_file_empty_file);
- check_fix(
- r#"
-//- /main.rs
-//- /foo.rs
-$0
-"#,
- r#"
-mod foo;
-"#,
- );
- }
+ fn import_extern_crate_clash_with_inner_item() {
+ // This is more of a resolver test, but doesn't really work with the hir_def testsuite.
- #[test]
- fn unlinked_file_old_style_modrs() {
- check_fix(
- r#"
-//- /main.rs
-mod submod;
-//- /submod/mod.rs
-// in mod.rs
-//- /submod/foo.rs
-$0
-"#,
+ check_diagnostics(
r#"
-// in mod.rs
-mod foo;
-"#,
- );
- }
+//- /lib.rs crate:lib deps:jwt
+mod permissions;
- #[test]
- fn unlinked_file_new_style_mod() {
- check_fix(
- r#"
-//- /main.rs
-mod submod;
-//- /submod.rs
-//- /submod/foo.rs
-$0
-"#,
- r#"
-mod foo;
-"#,
- );
- }
+use permissions::jwt;
- #[test]
- fn unlinked_file_with_cfg_off() {
- cov_mark::check!(unlinked_file_skip_fix_when_mod_already_exists);
- check_no_fix(
- r#"
-//- /main.rs
-#[cfg(never)]
-mod foo;
-
-//- /foo.rs
-$0
-"#,
- );
- }
+fn f() {
+ fn inner() {}
+ jwt::Claims {}; // should resolve to the local one with 0 fields, and not get a diagnostic
+}
- #[test]
- fn unlinked_file_with_cfg_on() {
- check_no_diagnostics(
- r#"
-//- /main.rs
-#[cfg(not(never))]
-mod foo;
+//- /permissions.rs
+pub mod jwt {
+ pub struct Claims {}
+}
-//- /foo.rs
-"#,
+//- /jwt/lib.rs crate:jwt
+pub struct Claims {
+ field: u8,
+}
+ "#,
);
}
}
projects / rust.git / blobdiff