//! 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 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::{
- diagnostics::{Diagnostic as _, DiagnosticCode, DiagnosticSinkBuilder},
+ diagnostics::{AnyDiagnostic, DiagnosticCode, DiagnosticSinkBuilder},
Semantics,
};
+use ide_assists::AssistResolveStrategy;
use ide_db::{base_db::SourceDatabase, RootDatabase};
use itertools::Itertools;
use rustc_hash::FxHashSet;
SyntaxNode, TextRange,
};
use text_edit::TextEdit;
+use unlinked_file::UnlinkedFile;
-use crate::{FileId, Label, SourceChange};
-
-use self::fixes::DiagnosticWithFix;
+use crate::{Assist, AssistId, AssistKind, FileId, Label, SourceChange};
#[derive(Debug)]
pub struct Diagnostic {
pub message: String,
pub range: TextRange,
pub severity: Severity,
- pub fix: Option<Fix>,
+ 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<Fix>) -> Self {
- Self { fix, ..self }
+ fn with_fixes(self, fixes: Option<Vec<Assist>>) -> Self {
+ Self { fixes, ..self }
}
fn with_unused(self, unused: bool) -> Self {
}
}
-#[derive(Debug)]
-pub struct Fix {
- pub label: Label,
- pub source_change: SourceChange,
- /// Allows to trigger the fix only when the caret is in the range given
- pub fix_trigger_range: TextRange,
-}
-
-impl Fix {
- fn new(label: &str, source_change: SourceChange, fix_trigger_range: TextRange) -> Self {
- let label = Label::new(label);
- Self { label, source_change, fix_trigger_range }
- }
-}
-
#[derive(Debug, Copy, Clone)]
pub enum Severity {
Error,
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,
+ resolve: &AssistResolveStrategy,
file_id: FileId,
) -> Vec<Diagnostic> {
let _p = profile::span("diagnostics");
}
let res = RefCell::new(res);
let sink_builder = DiagnosticSinkBuilder::new()
- .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
- res.borrow_mut().push(diagnostic_with_fix(d, &sema));
- })
- .on::<hir::diagnostics::MissingFields, _>(|d| {
- res.borrow_mut().push(diagnostic_with_fix(d, &sema));
- })
- .on::<hir::diagnostics::MissingOkOrSomeInTailExpr, _>(|d| {
- res.borrow_mut().push(diagnostic_with_fix(d, &sema));
- })
- .on::<hir::diagnostics::NoSuchField, _>(|d| {
- res.borrow_mut().push(diagnostic_with_fix(d, &sema));
- })
- .on::<hir::diagnostics::RemoveThisSemicolon, _>(|d| {
- res.borrow_mut().push(diagnostic_with_fix(d, &sema));
- })
- .on::<hir::diagnostics::IncorrectCase, _>(|d| {
- res.borrow_mut().push(warning_with_fix(d, &sema));
- })
- .on::<hir::diagnostics::ReplaceFilterMapNextWithFindMap, _>(|d| {
- res.borrow_mut().push(warning_with_fix(d, &sema));
- })
- .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).range, d.message())
- .with_unused(true)
- .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).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())));
- })
// 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()));
// Diagnostics not handled above get no fix and default treatment.
.build(|d| {
res.borrow_mut().push(
- Diagnostic::error(sema.diagnostics_display_range(d).range, d.message())
- .with_code(Some(d.code())),
+ Diagnostic::error(
+ sema.diagnostics_display_range(d.display_source()).range,
+ d.message(),
+ )
+ .with_code(Some(d.code())),
);
});
- if let Some(m) = sema.to_module_def(file_id) {
- m.diagnostics(db, &mut sink);
- };
+ 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>) -> Diagnostic {
- Diagnostic::error(sema.diagnostics_display_range(d).range, d.message())
- .with_fix(d.fix(&sema))
- .with_code(Some(d.code()))
-}
+ let mut res = res.into_inner();
+
+ 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
+ });
-fn warning_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
- Diagnostic::hint(sema.diagnostics_display_range(d).range, d.message())
- .with_fix(d.fix(&sema))
- .with_code(Some(d.code()))
+ 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::new(
+ .with_fixes(Some(vec![fix(
+ "remove_braces",
"Remove unnecessary braces",
SourceChange::from_text_edit(file_id, edit),
use_range,
- ))),
+ )])),
);
}
None
}
+fn fix(id: &'static str, label: &str, source_change: SourceChange, target: TextRange) -> Assist {
+ let mut res = unresolved_fix(id, label, target);
+ res.source_change = Some(source_change);
+ res
+}
+
+fn unresolved_fix(id: &'static str, label: &str, target: TextRange) -> Assist {
+ assert!(!id.contains(' '));
+ Assist {
+ id: AssistId(id, AssistKind::QuickFix),
+ label: Label::new(label),
+ group: None,
+ target,
+ source_change: None,
+ }
+}
+
#[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);
let diagnostic = analysis
- .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+ .diagnostics(
+ &DiagnosticsConfig::default(),
+ AssistResolveStrategy::All,
+ file_position.file_id,
+ )
.unwrap()
.pop()
.unwrap();
- let fix = diagnostic.fix.unwrap();
+ let fix = &diagnostic.fixes.unwrap()[nth];
let actual = {
- let file_id = *fix.source_change.source_file_edits.keys().next().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();
- for edit in fix.source_change.source_file_edits.values() {
+ for edit in source_change.source_file_edits.values() {
edit.apply(&mut actual);
}
actual
assert_eq_text!(&after, &actual);
assert!(
- fix.fix_trigger_range.contains_inclusive(file_position.offset),
+ fix.target.contains_inclusive(file_position.offset),
"diagnostic fix range {:?} does not touch cursor position {:?}",
- fix.fix_trigger_range,
+ fix.target,
file_position.offset
);
}
- /// 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(), file_id).unwrap()
- })
- .collect::<Vec<_>>();
- assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics);
+ /// Checks that there's a diagnostic *without* fix at `$0`.
+ pub(crate) fn check_no_fix(ra_fixture: &str) {
+ let (analysis, file_position) = fixture::position(ra_fixture);
+ let diagnostic = analysis
+ .diagnostics(
+ &DiagnosticsConfig::default(),
+ AssistResolveStrategy::All,
+ file_position.file_id,
+ )
+ .unwrap()
+ .pop()
+ .unwrap();
+ assert!(diagnostic.fixes.is_none(), "got a fix when none was expected: {:?}", diagnostic);
}
- fn check_expect(ra_fixture: &str, expect: Expect) {
+ pub(crate) fn check_expect(ra_fixture: &str, expect: Expect) {
let (analysis, file_id) = fixture::file(ra_fixture);
- let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
+ let diagnostics = analysis
+ .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id)
+ .unwrap();
expect.assert_debug_eq(&diagnostics)
}
- #[test]
- fn test_wrap_return_type_option() {
- check_fix(
- r#"
-//- /main.rs crate:main deps:core
-use core::option::Option::{self, Some, None};
-
-fn div(x: i32, y: i32) -> Option<i32> {
- if y == 0 {
- return None;
- }
- x / y$0
-}
-//- /core/lib.rs crate:core
-pub mod result {
- pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
- pub enum Option<T> { Some(T), None }
-}
-"#,
- r#"
-use core::option::Option::{self, Some, None};
-
-fn div(x: i32, y: i32) -> Option<i32> {
- if y == 0 {
- return None;
- }
- Some(x / y)
-}
-"#,
- );
- }
-
- #[test]
- fn test_wrap_return_type() {
- check_fix(
- r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-
-fn div(x: i32, y: i32) -> Result<i32, ()> {
- if y == 0 {
- return Err(());
- }
- x / y$0
-}
-//- /core/lib.rs crate:core
-pub mod result {
- pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
- pub enum Option<T> { Some(T), None }
-}
-"#,
- r#"
-use core::result::Result::{self, Ok, Err};
-
-fn div(x: i32, y: i32) -> Result<i32, ()> {
- if y == 0 {
- return Err(());
- }
- Ok(x / y)
-}
-"#,
- );
- }
-
- #[test]
- fn test_wrap_return_type_handles_generic_functions() {
- check_fix(
- r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-
-fn div<T>(x: T) -> Result<T, i32> {
- if x == 0 {
- return Err(7);
- }
- $0x
-}
-//- /core/lib.rs crate:core
-pub mod result {
- pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
- pub enum Option<T> { Some(T), None }
-}
-"#,
- r#"
-use core::result::Result::{self, Ok, Err};
-
-fn div<T>(x: T) -> Result<T, i32> {
- if x == 0 {
- return Err(7);
- }
- Ok(x)
-}
-"#,
- );
- }
-
- #[test]
- fn test_wrap_return_type_handles_type_aliases() {
- check_fix(
- r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-
-type MyResult<T> = Result<T, ()>;
-
-fn div(x: i32, y: i32) -> MyResult<i32> {
- if y == 0 {
- return Err(());
- }
- x $0/ y
-}
-//- /core/lib.rs crate:core
-pub mod result {
- pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
- pub enum Option<T> { Some(T), None }
-}
-"#,
- r#"
-use core::result::Result::{self, Ok, Err};
-
-type MyResult<T> = Result<T, ()>;
-
-fn div(x: i32, y: i32) -> MyResult<i32> {
- if y == 0 {
- return Err(());
- }
- Ok(x / y)
-}
-"#,
- );
- }
-
- #[test]
- fn test_wrap_return_type_not_applicable_when_expr_type_does_not_match_ok_type() {
- check_no_diagnostics(
- r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-
-fn foo() -> Result<(), i32> { 0 }
-
-//- /core/lib.rs crate:core
-pub mod result {
- pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
- pub enum Option<T> { Some(T), None }
-}
-"#,
- );
- }
-
- #[test]
- fn test_wrap_return_type_not_applicable_when_return_type_is_not_result_or_option() {
- check_no_diagnostics(
- r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-
-enum SomeOtherEnum { Ok(i32), Err(String) }
-
-fn foo() -> SomeOtherEnum { 0 }
-
-//- /core/lib.rs crate:core
-pub mod result {
- pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
- pub enum Option<T> { Some(T), None }
-}
-"#,
- );
- }
-
- #[test]
- fn test_fill_struct_fields_empty() {
- check_fix(
- r#"
-struct TestStruct { one: i32, two: i64 }
-
-fn test_fn() {
- let s = TestStruct {$0};
-}
-"#,
- r#"
-struct TestStruct { one: i32, two: i64 }
-
-fn test_fn() {
- let s = TestStruct { one: (), two: ()};
-}
-"#,
- );
- }
-
- #[test]
- fn test_fill_struct_fields_self() {
- check_fix(
- r#"
-struct TestStruct { one: i32 }
-
-impl TestStruct {
- fn test_fn() { let s = Self {$0}; }
-}
-"#,
- r#"
-struct TestStruct { one: i32 }
-
-impl TestStruct {
- fn test_fn() { let s = Self { one: ()}; }
-}
-"#,
- );
- }
-
- #[test]
- fn test_fill_struct_fields_enum() {
- check_fix(
- r#"
-enum Expr {
- Bin { lhs: Box<Expr>, rhs: Box<Expr> }
-}
-
-impl Expr {
- fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
- Expr::Bin {$0 }
- }
-}
-"#,
- r#"
-enum Expr {
- Bin { lhs: Box<Expr>, rhs: Box<Expr> }
-}
-
-impl Expr {
- fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
- Expr::Bin { lhs: (), rhs: () }
- }
-}
-"#,
- );
- }
-
- #[test]
- fn test_fill_struct_fields_partial() {
- check_fix(
- r#"
-struct TestStruct { one: i32, two: i64 }
-
-fn test_fn() {
- let s = TestStruct{ two: 2$0 };
-}
-"#,
- r"
-struct TestStruct { one: i32, two: i64 }
-
-fn test_fn() {
- let s = TestStruct{ two: 2, one: () };
-}
-",
- );
- }
-
- #[test]
- fn test_fill_struct_fields_no_diagnostic() {
- check_no_diagnostics(
- r"
- struct TestStruct { one: i32, two: i64 }
-
- fn test_fn() {
- let one = 1;
- let s = TestStruct{ one, two: 2 };
- }
- ",
- );
- }
-
- #[test]
- fn test_fill_struct_fields_no_diagnostic_on_spread() {
- check_no_diagnostics(
- r"
- struct TestStruct { one: i32, two: i64 }
-
- fn test_fn() {
- let one = 1;
- let s = TestStruct{ ..a };
- }
- ",
- );
- }
-
- #[test]
- fn test_unresolved_module_diagnostic() {
- check_expect(
- r#"mod foo;"#,
- expect![[r#"
- [
- Diagnostic {
- message: "unresolved module",
- range: 0..8,
- severity: Error,
- fix: Some(
- Fix {
- label: "Create module",
- source_change: SourceChange {
- source_file_edits: {},
- file_system_edits: [
- CreateFile {
- dst: AnchoredPathBuf {
- anchor: FileId(
- 0,
- ),
- path: "foo.rs",
- },
- initial_contents: "",
- },
- ],
- is_snippet: false,
- },
- fix_trigger_range: 0..8,
- },
- ),
- unused: false,
- code: Some(
- DiagnosticCode(
- "unresolved-module",
- ),
- ),
- },
- ]
- "#]],
- );
+ #[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 test_add_field_from_usage() {
- check_fix(
- r"
-fn main() {
- Foo { bar: 3, baz$0: false};
-}
-struct Foo {
- bar: i32
-}
-",
- r"
-fn main() {
- Foo { bar: 3, baz: false};
-}
-struct Foo {
- bar: i32,
- baz: bool
-}
-",
- )
- }
-
- #[test]
- fn test_add_field_in_other_file_from_usage() {
- check_fix(
- r#"
-//- /main.rs
-mod foo;
-
-fn main() {
- foo::Foo { bar: 3, $0baz: false};
-}
-//- /foo.rs
-struct Foo {
- bar: i32
-}
-"#,
- r#"
-struct Foo {
- bar: i32,
- pub(crate) baz: bool
-}
-"#,
- )
- }
-
#[test]
fn test_disabled_diagnostics() {
let mut config = DiagnosticsConfig::default();
let (analysis, file_id) = fixture::file(r#"mod foo;"#);
- let diagnostics = analysis.diagnostics(&config, file_id).unwrap();
+ let diagnostics =
+ analysis.diagnostics(&config, AssistResolveStrategy::All, file_id).unwrap();
assert!(diagnostics.is_empty());
- let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
+ let diagnostics = analysis
+ .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id)
+ .unwrap();
assert!(!diagnostics.is_empty());
}
#[test]
- fn test_rename_incorrect_case() {
- check_fix(
- r#"
-pub struct test_struct$0 { one: i32 }
+ 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.
-pub fn some_fn(val: test_struct) -> test_struct {
- test_struct { one: val.one + 1 }
-}
-"#,
+ check_diagnostics(
r#"
-pub struct TestStruct { one: i32 }
+//- /lib.rs crate:lib deps:jwt
+mod permissions;
-pub fn some_fn(val: TestStruct) -> TestStruct {
- TestStruct { one: val.one + 1 }
-}
-"#,
- );
+use permissions::jwt;
- check_fix(
- r#"
-pub fn some_fn(NonSnakeCase$0: u8) -> u8 {
- NonSnakeCase
-}
-"#,
- r#"
-pub fn some_fn(non_snake_case: u8) -> u8 {
- non_snake_case
+fn f() {
+ fn inner() {}
+ jwt::Claims {}; // should resolve to the local one with 0 fields, and not get a diagnostic
}
-"#,
- );
- check_fix(
- r#"
-pub fn SomeFn$0(val: u8) -> u8 {
- if val != 0 { SomeFn(val - 1) } else { val }
+//- /permissions.rs
+pub mod jwt {
+ pub struct Claims {}
}
-"#,
- r#"
-pub fn some_fn(val: u8) -> u8 {
- if val != 0 { some_fn(val - 1) } else { val }
-}
-"#,
- );
-
- check_fix(
- r#"
-fn some_fn() {
- let whatAWeird_Formatting$0 = 10;
- another_func(whatAWeird_Formatting);
-}
-"#,
- r#"
-fn some_fn() {
- let what_a_weird_formatting = 10;
- another_func(what_a_weird_formatting);
-}
-"#,
- );
- }
- #[test]
- fn test_uppercase_const_no_diagnostics() {
- check_no_diagnostics(
- r#"
-fn foo() {
- const ANOTHER_ITEM$0: &str = "some_item";
+//- /jwt/lib.rs crate:jwt
+pub struct Claims {
+ field: u8,
}
-"#,
+ "#,
);
}
-
- #[test]
- fn test_rename_incorrect_case_struct_method() {
- check_fix(
- r#"
-pub struct TestStruct;
-
-impl TestStruct {
- pub fn SomeFn$0() -> TestStruct {
- TestStruct
- }
-}
-"#,
- r#"
-pub struct TestStruct;
-
-impl TestStruct {
- pub fn some_fn() -> TestStruct {
- TestStruct
- }
-}
-"#,
- );
- }
-
- #[test]
- fn test_single_incorrect_case_diagnostic_in_function_name_issue_6970() {
- let input = r#"fn FOO$0() {}"#;
- let expected = r#"fn foo() {}"#;
-
- let (analysis, file_position) = fixture::position(input);
- let diagnostics =
- analysis.diagnostics(&DiagnosticsConfig::default(), file_position.file_id).unwrap();
- assert_eq!(diagnostics.len(), 1);
-
- check_fix(input, expected);
- }
}
projects / rust.git / blobdiff