//! 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::DiagnosticWithFixes;
-
#[derive(Debug)]
pub struct Diagnostic {
// pub name: Option<String>,
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, fixes: 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 {
fixes: None,
unused: false,
code: None,
+ experimental: false,
}
}
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_fixes(d.fixes(&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())));
- })
- .on::<hir::diagnostics::UnimplementedBuiltinMacro, _>(|d| {
- let display_range = sema.diagnostics_display_range(d.display_source()).range;
- 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()));
);
});
- let internal_diagnostics = cfg!(test);
- match sema.to_module_def(file_id) {
- Some(m) => m.diagnostics(db, &mut sink, internal_diagnostics),
- 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: DiagnosticWithFixes>(
- d: &D,
- sema: &Semantics<RootDatabase>,
- resolve: &AssistResolveStrategy,
-) -> Diagnostic {
- Diagnostic::error(sema.diagnostics_display_range(d.display_source()).range, d.message())
- .with_fixes(d.fixes(&sema, resolve))
- .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)
+ }
-fn warning_with_fix<D: DiagnosticWithFixes>(
- d: &D,
- sema: &Semantics<RootDatabase>,
- resolve: &AssistResolveStrategy,
-) -> Diagnostic {
- Diagnostic::hint(sema.diagnostics_display_range(d.display_source()).range, d.message())
- .with_fixes(d.fixes(&sema, resolve))
- .with_code(Some(d.code()))
+ 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(
#[cfg(test)]
mod tests {
use expect_test::Expect;
- use hir::diagnostics::DiagnosticCode;
use ide_assists::AssistResolveStrategy;
use stdx::trim_indent;
use test_utils::{assert_eq_text, extract_annotations};
file_position.offset
);
}
+
/// 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(
assert!(diagnostic.fixes.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);
- }
-
pub(crate) fn check_expect(ra_fixture: &str, expect: Expect) {
let (analysis, file_id) = fixture::file(ra_fixture);
let diagnostics = analysis
expect.assert_debug_eq(&diagnostics)
}
+ #[track_caller]
pub(crate) fn check_diagnostics(ra_fixture: &str) {
- let (analysis, file_id) = fixture::file(ra_fixture);
- let diagnostics = analysis
- .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id)
- .unwrap();
-
- let expected = extract_annotations(&*analysis.file_text(file_id).unwrap());
- let mut actual = diagnostics
- .into_iter()
- .filter(|d| d.code != Some(DiagnosticCode("inactive-code")))
- .map(|d| (d.range, d.message))
- .collect::<Vec<_>>();
- actual.sort_by_key(|(range, _)| range.start());
- assert_eq!(expected, actual);
- }
-
- #[test]
- fn test_unresolved_macro_range() {
- check_diagnostics(
- r#"
-foo::bar!(92);
- //^^^ unresolved macro `foo::bar!`
-"#,
- );
- }
-
- #[test]
- fn unresolved_import_in_use_tree() {
- // Only the relevant part of a nested `use` item should be highlighted.
- check_diagnostics(
- r#"
-use does_exist::{Exists, DoesntExist};
- //^^^^^^^^^^^ unresolved import
-
-use {does_not_exist::*, does_exist};
- //^^^^^^^^^^^^^^^^^ unresolved import
-
-use does_not_exist::{
- a,
- //^ unresolved import
- b,
- //^ unresolved import
- c,
- //^ unresolved import
-};
-
-mod does_exist {
- pub struct Exists;
-}
-"#,
- );
+ 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);
- // Only tests the first one for `pub mod` since the rest are the same
- check_fixes(
- r#"
-//- /main.rs
-fn f() {}
-//- /foo.rs
-$0
-"#,
- vec![
- r#"
-mod foo;
-
-fn f() {}
-"#,
- r#"
-pub 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;
-"#,
- );
- }
-
- #[test]
- fn unlinked_file_old_style_modrs() {
- check_fix(
- r#"
-//- /main.rs
-mod submod;
-//- /submod/mod.rs
-// in mod.rs
-//- /submod/foo.rs
-$0
-"#,
- r#"
-// in mod.rs
-mod foo;
-"#,
- );
- }
-
- #[test]
- fn unlinked_file_new_style_mod() {
- check_fix(
- r#"
-//- /main.rs
-mod submod;
-//- /submod.rs
-//- /submod/foo.rs
-$0
-"#,
- r#"
-mod foo;
-"#,
- );
- }
-
- #[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
-"#,
- );
- }
-
- #[test]
- fn unlinked_file_with_cfg_on() {
- check_no_diagnostics(
- r#"
-//- /main.rs
-#[cfg(not(never))]
-mod foo;
-
-//- /foo.rs
-"#,
- );
- }
-
- #[test]
- fn break_outside_of_loop() {
- check_diagnostics(
- r#"
-fn foo() { break; }
- //^^^^^ break outside of loop
-"#,
- );
- }
-
- #[test]
- fn no_such_field_diagnostics() {
- check_diagnostics(
- r#"
-struct S { foo: i32, bar: () }
-impl S {
- fn new() -> S {
- S {
- //^ Missing structure fields:
- //| - bar
- foo: 92,
- baz: 62,
- //^^^^^^^ no such field
- }
- }
-}
-"#,
- );
- }
- #[test]
- fn no_such_field_with_feature_flag_diagnostics() {
- check_diagnostics(
- r#"
-//- /lib.rs crate:foo cfg:feature=foo
-struct MyStruct {
- my_val: usize,
- #[cfg(feature = "foo")]
- bar: bool,
-}
-
-impl MyStruct {
- #[cfg(feature = "foo")]
- pub(crate) fn new(my_val: usize, bar: bool) -> Self {
- Self { my_val, bar }
- }
- #[cfg(not(feature = "foo"))]
- pub(crate) fn new(my_val: usize, _bar: bool) -> Self {
- Self { my_val }
- }
-}
-"#,
- );
- }
-
- #[test]
- fn no_such_field_enum_with_feature_flag_diagnostics() {
- check_diagnostics(
- r#"
-//- /lib.rs crate:foo cfg:feature=foo
-enum Foo {
- #[cfg(not(feature = "foo"))]
- Buz,
- #[cfg(feature = "foo")]
- Bar,
- Baz
-}
-
-fn test_fn(f: Foo) {
- match f {
- Foo::Bar => {},
- Foo::Baz => {},
- }
-}
-"#,
- );
- }
-
- #[test]
- fn no_such_field_with_feature_flag_diagnostics_on_struct_lit() {
- check_diagnostics(
- r#"
-//- /lib.rs crate:foo cfg:feature=foo
-struct S {
- #[cfg(feature = "foo")]
- foo: u32,
- #[cfg(not(feature = "foo"))]
- bar: u32,
-}
-
-impl S {
- #[cfg(feature = "foo")]
- fn new(foo: u32) -> Self {
- Self { foo }
- }
- #[cfg(not(feature = "foo"))]
- fn new(bar: u32) -> Self {
- Self { bar }
- }
- fn new2(bar: u32) -> Self {
- #[cfg(feature = "foo")]
- { Self { foo: bar } }
- #[cfg(not(feature = "foo"))]
- { Self { bar } }
- }
- fn new2(val: u32) -> Self {
- Self {
- #[cfg(feature = "foo")]
- foo: val,
- #[cfg(not(feature = "foo"))]
- bar: val,
- }
- }
-}
-"#,
- );
- }
-
- #[test]
- fn no_such_field_with_type_macro() {
- check_diagnostics(
- r#"
-macro_rules! Type { () => { u32 }; }
-struct Foo { bar: Type![] }
-
-impl Foo {
- fn new() -> Self {
- Foo { bar: 0 }
- }
-}
-"#,
- );
- }
+ 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 missing_unsafe_diagnostic_with_raw_ptr() {
- check_diagnostics(
- r#"
-fn main() {
- let x = &5 as *const usize;
- unsafe { let y = *x; }
- let z = *x;
-} //^^ This operation is unsafe and requires an unsafe function or block
-"#,
- )
- }
-
- #[test]
- fn missing_unsafe_diagnostic_with_unsafe_call() {
check_diagnostics(
r#"
-struct HasUnsafe;
-
-impl HasUnsafe {
- unsafe fn unsafe_fn(&self) {
- let x = &5 as *const usize;
- let y = *x;
- }
-}
+//- /lib.rs crate:lib deps:jwt
+mod permissions;
-unsafe fn unsafe_fn() {
- let x = &5 as *const usize;
- let y = *x;
-}
+use permissions::jwt;
-fn main() {
- unsafe_fn();
- //^^^^^^^^^^^ This operation is unsafe and requires an unsafe function or block
- HasUnsafe.unsafe_fn();
- //^^^^^^^^^^^^^^^^^^^^^ This operation is unsafe and requires an unsafe function or block
- unsafe {
- unsafe_fn();
- HasUnsafe.unsafe_fn();
- }
+fn f() {
+ fn inner() {}
+ jwt::Claims {}; // should resolve to the local one with 0 fields, and not get a diagnostic
}
-"#,
- );
- }
- #[test]
- fn missing_unsafe_diagnostic_with_static_mut() {
- check_diagnostics(
- r#"
-struct Ty {
- a: u8,
+//- /permissions.rs
+pub mod jwt {
+ pub struct Claims {}
}
-static mut STATIC_MUT: Ty = Ty { a: 0 };
-
-fn main() {
- let x = STATIC_MUT.a;
- //^^^^^^^^^^ This operation is unsafe and requires an unsafe function or block
- unsafe {
- let x = STATIC_MUT.a;
- }
+//- /jwt/lib.rs crate:jwt
+pub struct Claims {
+ field: u8,
}
-"#,
+ "#,
);
}
-
- #[test]
- fn no_missing_unsafe_diagnostic_with_safe_intrinsic() {
- check_diagnostics(
- r#"
-extern "rust-intrinsic" {
- pub fn bitreverse(x: u32) -> u32; // Safe intrinsic
- pub fn floorf32(x: f32) -> f32; // Unsafe intrinsic
-}
-
-fn main() {
- let _ = bitreverse(12);
- let _ = floorf32(12.0);
- //^^^^^^^^^^^^^^ This operation is unsafe and requires an unsafe function or block
-}
-"#,
- );
- }
-
- // Register the required standard library types to make the tests work
- fn add_filter_map_with_find_next_boilerplate(body: &str) -> String {
- let prefix = r#"
- //- /main.rs crate:main deps:core
- use core::iter::Iterator;
- use core::option::Option::{self, Some, None};
- "#;
- let suffix = r#"
- //- /core/lib.rs crate:core
- pub mod option {
- pub enum Option<T> { Some(T), None }
- }
- pub mod iter {
- pub trait Iterator {
- type Item;
- fn filter_map<B, F>(self, f: F) -> FilterMap where F: FnMut(Self::Item) -> Option<B> { FilterMap }
- fn next(&mut self) -> Option<Self::Item>;
- }
- pub struct FilterMap {}
- impl Iterator for FilterMap {
- type Item = i32;
- fn next(&mut self) -> i32 { 7 }
- }
- }
- "#;
- format!("{}{}{}", prefix, body, suffix)
- }
-
- #[test]
- fn replace_filter_map_next_with_find_map2() {
- check_diagnostics(&add_filter_map_with_find_next_boilerplate(
- r#"
- fn foo() {
- let m = [1, 2, 3].iter().filter_map(|x| if *x == 2 { Some (4) } else { None }).next();
- //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ replace filter_map(..).next() with find_map(..)
- }
- "#,
- ));
- }
-
- #[test]
- fn replace_filter_map_next_with_find_map_no_diagnostic_without_next() {
- check_diagnostics(&add_filter_map_with_find_next_boilerplate(
- r#"
- fn foo() {
- let m = [1, 2, 3]
- .iter()
- .filter_map(|x| if *x == 2 { Some (4) } else { None })
- .len();
- }
- "#,
- ));
- }
-
- #[test]
- fn replace_filter_map_next_with_find_map_no_diagnostic_with_intervening_methods() {
- check_diagnostics(&add_filter_map_with_find_next_boilerplate(
- r#"
- fn foo() {
- let m = [1, 2, 3]
- .iter()
- .filter_map(|x| if *x == 2 { Some (4) } else { None })
- .map(|x| x + 2)
- .len();
- }
- "#,
- ));
- }
-
- #[test]
- fn replace_filter_map_next_with_find_map_no_diagnostic_if_not_in_chain() {
- check_diagnostics(&add_filter_map_with_find_next_boilerplate(
- r#"
- fn foo() {
- let m = [1, 2, 3]
- .iter()
- .filter_map(|x| if *x == 2 { Some (4) } else { None });
- let n = m.next();
- }
- "#,
- ));
- }
-
- #[test]
- fn missing_record_pat_field_diagnostic() {
- check_diagnostics(
- r#"
-struct S { foo: i32, bar: () }
-fn baz(s: S) {
- let S { foo: _ } = s;
- //^ Missing structure fields:
- //| - bar
-}
-"#,
- );
- }
-
- #[test]
- fn missing_record_pat_field_no_diagnostic_if_not_exhaustive() {
- check_diagnostics(
- r"
-struct S { foo: i32, bar: () }
-fn baz(s: S) -> i32 {
- match s {
- S { foo, .. } => foo,
- }
-}
-",
- )
- }
-
- #[test]
- fn missing_record_pat_field_box() {
- check_diagnostics(
- r"
-struct S { s: Box<u32> }
-fn x(a: S) {
- let S { box s } = a;
-}
-",
- )
- }
-
- #[test]
- fn missing_record_pat_field_ref() {
- check_diagnostics(
- r"
-struct S { s: u32 }
-fn x(a: S) {
- let S { ref s } = a;
-}
-",
- )
- }
-
- #[test]
- fn simple_free_fn_zero() {
- check_diagnostics(
- r#"
-fn zero() {}
-fn f() { zero(1); }
- //^^^^^^^ Expected 0 arguments, found 1
-"#,
- );
-
- check_diagnostics(
- r#"
-fn zero() {}
-fn f() { zero(); }
-"#,
- );
- }
-
- #[test]
- fn simple_free_fn_one() {
- check_diagnostics(
- r#"
-fn one(arg: u8) {}
-fn f() { one(); }
- //^^^^^ Expected 1 argument, found 0
-"#,
- );
-
- check_diagnostics(
- r#"
-fn one(arg: u8) {}
-fn f() { one(1); }
-"#,
- );
- }
-
- #[test]
- fn method_as_fn() {
- check_diagnostics(
- r#"
-struct S;
-impl S { fn method(&self) {} }
-
-fn f() {
- S::method();
-} //^^^^^^^^^^^ Expected 1 argument, found 0
-"#,
- );
-
- check_diagnostics(
- r#"
-struct S;
-impl S { fn method(&self) {} }
-
-fn f() {
- S::method(&S);
- S.method();
-}
-"#,
- );
- }
-
- #[test]
- fn method_with_arg() {
- check_diagnostics(
- r#"
-struct S;
-impl S { fn method(&self, arg: u8) {} }
-
- fn f() {
- S.method();
- } //^^^^^^^^^^ Expected 1 argument, found 0
- "#,
- );
-
- check_diagnostics(
- r#"
-struct S;
-impl S { fn method(&self, arg: u8) {} }
-
-fn f() {
- S::method(&S, 0);
- S.method(1);
-}
-"#,
- );
- }
-
- #[test]
- fn method_unknown_receiver() {
- // note: this is incorrect code, so there might be errors on this in the
- // future, but we shouldn't emit an argument count diagnostic here
- check_diagnostics(
- r#"
-trait Foo { fn method(&self, arg: usize) {} }
-
-fn f() {
- let x;
- x.method();
-}
-"#,
- );
- }
-
- #[test]
- fn tuple_struct() {
- check_diagnostics(
- r#"
-struct Tup(u8, u16);
-fn f() {
- Tup(0);
-} //^^^^^^ Expected 2 arguments, found 1
-"#,
- )
- }
-
- #[test]
- fn enum_variant() {
- check_diagnostics(
- r#"
-enum En { Variant(u8, u16), }
-fn f() {
- En::Variant(0);
-} //^^^^^^^^^^^^^^ Expected 2 arguments, found 1
-"#,
- )
- }
-
- #[test]
- fn enum_variant_type_macro() {
- check_diagnostics(
- r#"
-macro_rules! Type {
- () => { u32 };
-}
-enum Foo {
- Bar(Type![])
-}
-impl Foo {
- fn new() {
- Foo::Bar(0);
- Foo::Bar(0, 1);
- //^^^^^^^^^^^^^^ Expected 1 argument, found 2
- Foo::Bar();
- //^^^^^^^^^^ Expected 1 argument, found 0
- }
-}
- "#,
- );
- }
-
- #[test]
- fn varargs() {
- check_diagnostics(
- r#"
-extern "C" {
- fn fixed(fixed: u8);
- fn varargs(fixed: u8, ...);
- fn varargs2(...);
-}
-
-fn f() {
- unsafe {
- fixed(0);
- fixed(0, 1);
- //^^^^^^^^^^^ Expected 1 argument, found 2
- varargs(0);
- varargs(0, 1);
- varargs2();
- varargs2(0);
- varargs2(0, 1);
- }
-}
- "#,
- )
- }
-
- #[test]
- fn arg_count_lambda() {
- check_diagnostics(
- r#"
-fn main() {
- let f = |()| ();
- f();
- //^^^ Expected 1 argument, found 0
- f(());
- f((), ());
- //^^^^^^^^^ Expected 1 argument, found 2
-}
-"#,
- )
- }
-
- #[test]
- fn cfgd_out_call_arguments() {
- check_diagnostics(
- r#"
-struct C(#[cfg(FALSE)] ());
-impl C {
- fn new() -> Self {
- Self(
- #[cfg(FALSE)]
- (),
- )
- }
-
- fn method(&self) {}
-}
-
-fn main() {
- C::new().method(#[cfg(FALSE)] 0);
-}
- "#,
- );
- }
-
- #[test]
- fn cfgd_out_fn_params() {
- check_diagnostics(
- r#"
-fn foo(#[cfg(NEVER)] x: ()) {}
-
-struct S;
-
-impl S {
- fn method(#[cfg(NEVER)] self) {}
- fn method2(#[cfg(NEVER)] self, arg: u8) {}
- fn method3(self, #[cfg(NEVER)] arg: u8) {}
-}
-
-extern "C" {
- fn fixed(fixed: u8, #[cfg(NEVER)] ...);
- fn varargs(#[cfg(not(NEVER))] ...);
-}
-
-fn main() {
- foo();
- S::method();
- S::method2(0);
- S::method3(S);
- S.method3();
- unsafe {
- fixed(0);
- varargs(1, 2, 3);
- }
-}
- "#,
- )
- }
-
- #[test]
- fn missing_semicolon() {
- check_diagnostics(
- r#"
- fn test() -> i32 { 123; }
- //^^^ Remove this semicolon
- "#,
- );
- }
-}
-
-#[cfg(test)]
-pub(super) mod match_check_tests {
- use crate::diagnostics::tests::check_diagnostics;
-
- #[test]
- fn empty_tuple() {
- check_diagnostics(
- r#"
-fn main() {
- match () { }
- //^^ Missing match arm
- match (()) { }
- //^^^^ Missing match arm
-
- match () { _ => (), }
- match () { () => (), }
- match (()) { (()) => (), }
-}
-"#,
- );
- }
-
- #[test]
- fn tuple_of_two_empty_tuple() {
- check_diagnostics(
- r#"
-fn main() {
- match ((), ()) { }
- //^^^^^^^^ Missing match arm
-
- match ((), ()) { ((), ()) => (), }
-}
-"#,
- );
- }
-
- #[test]
- fn boolean() {
- check_diagnostics(
- r#"
-fn test_main() {
- match false { }
- //^^^^^ Missing match arm
- match false { true => (), }
- //^^^^^ Missing match arm
- match (false, true) {}
- //^^^^^^^^^^^^^ Missing match arm
- match (false, true) { (true, true) => (), }
- //^^^^^^^^^^^^^ Missing match arm
- match (false, true) {
- //^^^^^^^^^^^^^ Missing match arm
- (false, true) => (),
- (false, false) => (),
- (true, false) => (),
- }
- match (false, true) { (true, _x) => (), }
- //^^^^^^^^^^^^^ Missing match arm
-
- match false { true => (), false => (), }
- match (false, true) {
- (false, _) => (),
- (true, false) => (),
- (_, true) => (),
- }
- match (false, true) {
- (true, true) => (),
- (true, false) => (),
- (false, true) => (),
- (false, false) => (),
- }
- match (false, true) {
- (true, _x) => (),
- (false, true) => (),
- (false, false) => (),
- }
- match (false, true, false) {
- (false, ..) => (),
- (true, ..) => (),
- }
- match (false, true, false) {
- (.., false) => (),
- (.., true) => (),
- }
- match (false, true, false) { (..) => (), }
-}
-"#,
- );
- }
-
- #[test]
- fn tuple_of_tuple_and_bools() {
- check_diagnostics(
- r#"
-fn main() {
- match (false, ((), false)) {}
- //^^^^^^^^^^^^^^^^^^^^ Missing match arm
- match (false, ((), false)) { (true, ((), true)) => (), }
- //^^^^^^^^^^^^^^^^^^^^ Missing match arm
- match (false, ((), false)) { (true, _) => (), }
- //^^^^^^^^^^^^^^^^^^^^ Missing match arm
-
- match (false, ((), false)) {
- (true, ((), true)) => (),
- (true, ((), false)) => (),
- (false, ((), true)) => (),
- (false, ((), false)) => (),
- }
- match (false, ((), false)) {
- (true, ((), true)) => (),
- (true, ((), false)) => (),
- (false, _) => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn enums() {
- check_diagnostics(
- r#"
-enum Either { A, B, }
-
-fn main() {
- match Either::A { }
- //^^^^^^^^^ Missing match arm
- match Either::B { Either::A => (), }
- //^^^^^^^^^ Missing match arm
-
- match &Either::B {
- //^^^^^^^^^^ Missing match arm
- Either::A => (),
- }
-
- match Either::B {
- Either::A => (), Either::B => (),
- }
- match &Either::B {
- Either::A => (), Either::B => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn enum_containing_bool() {
- check_diagnostics(
- r#"
-enum Either { A(bool), B }
-
-fn main() {
- match Either::B { }
- //^^^^^^^^^ Missing match arm
- match Either::B {
- //^^^^^^^^^ Missing match arm
- Either::A(true) => (), Either::B => ()
- }
-
- match Either::B {
- Either::A(true) => (),
- Either::A(false) => (),
- Either::B => (),
- }
- match Either::B {
- Either::B => (),
- _ => (),
- }
- match Either::B {
- Either::A(_) => (),
- Either::B => (),
- }
-
-}
- "#,
- );
- }
-
- #[test]
- fn enum_different_sizes() {
- check_diagnostics(
- r#"
-enum Either { A(bool), B(bool, bool) }
-
-fn main() {
- match Either::A(false) {
- //^^^^^^^^^^^^^^^^ Missing match arm
- Either::A(_) => (),
- Either::B(false, _) => (),
- }
-
- match Either::A(false) {
- Either::A(_) => (),
- Either::B(true, _) => (),
- Either::B(false, _) => (),
- }
- match Either::A(false) {
- Either::A(true) | Either::A(false) => (),
- Either::B(true, _) => (),
- Either::B(false, _) => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn tuple_of_enum_no_diagnostic() {
- check_diagnostics(
- r#"
-enum Either { A(bool), B(bool, bool) }
-enum Either2 { C, D }
-
-fn main() {
- match (Either::A(false), Either2::C) {
- (Either::A(true), _) | (Either::A(false), _) => (),
- (Either::B(true, _), Either2::C) => (),
- (Either::B(false, _), Either2::C) => (),
- (Either::B(_, _), Either2::D) => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn or_pattern_no_diagnostic() {
- check_diagnostics(
- r#"
-enum Either {A, B}
-
-fn main() {
- match (Either::A, Either::B) {
- (Either::A | Either::B, _) => (),
- }
-}"#,
- )
- }
-
- #[test]
- fn mismatched_types() {
- // Match statements with arms that don't match the
- // expression pattern do not fire this diagnostic.
- check_diagnostics(
- r#"
-enum Either { A, B }
-enum Either2 { C, D }
-
-fn main() {
- match Either::A {
- Either2::C => (),
- // ^^^^^^^^^^ Internal: match check bailed out
- Either2::D => (),
- }
- match (true, false) {
- (true, false, true) => (),
- // ^^^^^^^^^^^^^^^^^^^ Internal: match check bailed out
- (true) => (),
- }
- match (true, false) { (true,) => {} }
- // ^^^^^^^ Internal: match check bailed out
- match (0) { () => () }
- // ^^ Internal: match check bailed out
- match Unresolved::Bar { Unresolved::Baz => () }
-}
- "#,
- );
- }
-
- #[test]
- fn mismatched_types_in_or_patterns() {
- check_diagnostics(
- r#"
-fn main() {
- match false { true | () => {} }
- // ^^^^^^^^^ Internal: match check bailed out
- match (false,) { (true | (),) => {} }
- // ^^^^^^^^^^^^ Internal: match check bailed out
-}
-"#,
- );
- }
-
- #[test]
- fn malformed_match_arm_tuple_enum_missing_pattern() {
- // We are testing to be sure we don't panic here when the match
- // arm `Either::B` is missing its pattern.
- check_diagnostics(
- r#"
-enum Either { A, B(u32) }
-
-fn main() {
- match Either::A {
- Either::A => (),
- Either::B() => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn malformed_match_arm_extra_fields() {
- check_diagnostics(
- r#"
-enum A { B(isize, isize), C }
-fn main() {
- match A::B(1, 2) {
- A::B(_, _, _) => (),
- // ^^^^^^^^^^^^^ Internal: match check bailed out
- }
- match A::B(1, 2) {
- A::C(_) => (),
- // ^^^^^^^ Internal: match check bailed out
- }
-}
-"#,
- );
- }
-
- #[test]
- fn expr_diverges() {
- check_diagnostics(
- r#"
-enum Either { A, B }
-
-fn main() {
- match loop {} {
- Either::A => (),
- // ^^^^^^^^^ Internal: match check bailed out
- Either::B => (),
- }
- match loop {} {
- Either::A => (),
- // ^^^^^^^^^ Internal: match check bailed out
- }
- match loop { break Foo::A } {
- //^^^^^^^^^^^^^^^^^^^^^ Missing match arm
- Either::A => (),
- }
- match loop { break Foo::A } {
- Either::A => (),
- Either::B => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn expr_partially_diverges() {
- check_diagnostics(
- r#"
-enum Either<T> { A(T), B }
-
-fn foo() -> Either<!> { Either::B }
-fn main() -> u32 {
- match foo() {
- Either::A(val) => val,
- Either::B => 0,
- }
-}
-"#,
- );
- }
-
- #[test]
- fn enum_record() {
- check_diagnostics(
- r#"
-enum Either { A { foo: bool }, B }
-
-fn main() {
- let a = Either::A { foo: true };
- match a { }
- //^ Missing match arm
- match a { Either::A { foo: true } => () }
- //^ Missing match arm
- match a {
- Either::A { } => (),
- //^^^^^^^^^ Missing structure fields:
- // | - foo
- Either::B => (),
- }
- match a {
- //^ Missing match arm
- Either::A { } => (),
- } //^^^^^^^^^ Missing structure fields:
- // | - foo
-
- match a {
- Either::A { foo: true } => (),
- Either::A { foo: false } => (),
- Either::B => (),
- }
- match a {
- Either::A { foo: _ } => (),
- Either::B => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn enum_record_fields_out_of_order() {
- check_diagnostics(
- r#"
-enum Either {
- A { foo: bool, bar: () },
- B,
-}
-
-fn main() {
- let a = Either::A { foo: true, bar: () };
- match a {
- //^ Missing match arm
- Either::A { bar: (), foo: false } => (),
- Either::A { foo: true, bar: () } => (),
- }
-
- match a {
- Either::A { bar: (), foo: false } => (),
- Either::A { foo: true, bar: () } => (),
- Either::B => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn enum_record_ellipsis() {
- check_diagnostics(
- r#"
-enum Either {
- A { foo: bool, bar: bool },
- B,
-}
-
-fn main() {
- let a = Either::B;
- match a {
- //^ Missing match arm
- Either::A { foo: true, .. } => (),
- Either::B => (),
- }
- match a {
- //^ Missing match arm
- Either::A { .. } => (),
- }
-
- match a {
- Either::A { foo: true, .. } => (),
- Either::A { foo: false, .. } => (),
- Either::B => (),
- }
-
- match a {
- Either::A { .. } => (),
- Either::B => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn enum_tuple_partial_ellipsis() {
- check_diagnostics(
- r#"
-enum Either {
- A(bool, bool, bool, bool),
- B,
-}
-
-fn main() {
- match Either::B {
- //^^^^^^^^^ Missing match arm
- Either::A(true, .., true) => (),
- Either::A(true, .., false) => (),
- Either::A(false, .., false) => (),
- Either::B => (),
- }
- match Either::B {
- //^^^^^^^^^ Missing match arm
- Either::A(true, .., true) => (),
- Either::A(true, .., false) => (),
- Either::A(.., true) => (),
- Either::B => (),
- }
-
- match Either::B {
- Either::A(true, .., true) => (),
- Either::A(true, .., false) => (),
- Either::A(false, .., true) => (),
- Either::A(false, .., false) => (),
- Either::B => (),
- }
- match Either::B {
- Either::A(true, .., true) => (),
- Either::A(true, .., false) => (),
- Either::A(.., true) => (),
- Either::A(.., false) => (),
- Either::B => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn never() {
- check_diagnostics(
- r#"
-enum Never {}
-
-fn enum_(never: Never) {
- match never {}
-}
-fn enum_ref(never: &Never) {
- match never {}
- //^^^^^ Missing match arm
-}
-fn bang(never: !) {
- match never {}
-}
-"#,
- );
- }
-
- #[test]
- fn unknown_type() {
- check_diagnostics(
- r#"
-enum Option<T> { Some(T), None }
-
-fn main() {
- // `Never` is deliberately not defined so that it's an uninferred type.
- match Option::<Never>::None {
- None => (),
- Some(never) => match never {},
- // ^^^^^^^^^^^ Internal: match check bailed out
- }
- match Option::<Never>::None {
- //^^^^^^^^^^^^^^^^^^^^^ Missing match arm
- Option::Some(_never) => {},
- }
-}
-"#,
- );
- }
-
- #[test]
- fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
- check_diagnostics(
- r#"
-fn main() {
- match (false, true, false) {
- //^^^^^^^^^^^^^^^^^^^^ Missing match arm
- (false, ..) => (),
- }
-}"#,
- );
- }
-
- #[test]
- fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
- check_diagnostics(
- r#"
-fn main() {
- match (false, true, false) {
- //^^^^^^^^^^^^^^^^^^^^ Missing match arm
- (.., false) => (),
- }
-}"#,
- );
- }
-
- #[test]
- fn tuple_of_bools_with_ellipsis_in_middle_missing_arm() {
- check_diagnostics(
- r#"
-fn main() {
- match (false, true, false) {
- //^^^^^^^^^^^^^^^^^^^^ Missing match arm
- (true, .., false) => (),
- }
-}"#,
- );
- }
-
- #[test]
- fn record_struct() {
- check_diagnostics(
- r#"struct Foo { a: bool }
-fn main(f: Foo) {
- match f {}
- //^ Missing match arm
- match f { Foo { a: true } => () }
- //^ Missing match arm
- match &f { Foo { a: true } => () }
- //^^ Missing match arm
- match f { Foo { a: _ } => () }
- match f {
- Foo { a: true } => (),
- Foo { a: false } => (),
- }
- match &f {
- Foo { a: true } => (),
- Foo { a: false } => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn tuple_struct() {
- check_diagnostics(
- r#"struct Foo(bool);
-fn main(f: Foo) {
- match f {}
- //^ Missing match arm
- match f { Foo(true) => () }
- //^ Missing match arm
- match f {
- Foo(true) => (),
- Foo(false) => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn unit_struct() {
- check_diagnostics(
- r#"struct Foo;
-fn main(f: Foo) {
- match f {}
- //^ Missing match arm
- match f { Foo => () }
-}
-"#,
- );
- }
-
- #[test]
- fn record_struct_ellipsis() {
- check_diagnostics(
- r#"struct Foo { foo: bool, bar: bool }
-fn main(f: Foo) {
- match f { Foo { foo: true, .. } => () }
- //^ Missing match arm
- match f {
- //^ Missing match arm
- Foo { foo: true, .. } => (),
- Foo { bar: false, .. } => ()
- }
- match f { Foo { .. } => () }
- match f {
- Foo { foo: true, .. } => (),
- Foo { foo: false, .. } => ()
- }
-}
-"#,
- );
- }
-
- #[test]
- fn internal_or() {
- check_diagnostics(
- r#"
-fn main() {
- enum Either { A(bool), B }
- match Either::B {
- //^^^^^^^^^ Missing match arm
- Either::A(true | false) => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn no_panic_at_unimplemented_subpattern_type() {
- check_diagnostics(
- r#"
-struct S { a: char}
-fn main(v: S) {
- match v { S{ a } => {} }
- match v { S{ a: _x } => {} }
- match v { S{ a: 'a' } => {} }
- //^^^^^^^^^^^ Internal: match check bailed out
- match v { S{..} => {} }
- match v { _ => {} }
- match v { }
- //^ Missing match arm
-}
-"#,
- );
- }
-
- #[test]
- fn binding() {
- check_diagnostics(
- r#"
-fn main() {
- match true {
- _x @ true => {}
- false => {}
- }
- match true { _x @ true => {} }
- //^^^^ Missing match arm
-}
-"#,
- );
- }
-
- #[test]
- fn binding_ref_has_correct_type() {
- // Asserts `PatKind::Binding(ref _x): bool`, not &bool.
- // If that's not true match checking will panic with "incompatible constructors"
- // FIXME: make facilities to test this directly like `tests::check_infer(..)`
- check_diagnostics(
- r#"
-enum Foo { A }
-fn main() {
- // FIXME: this should not bail out but current behavior is such as the old algorithm.
- // ExprValidator::validate_match(..) checks types of top level patterns incorrecly.
- match Foo::A {
- ref _x => {}
- // ^^^^^^ Internal: match check bailed out
- Foo::A => {}
- }
- match (true,) {
- (ref _x,) => {}
- (true,) => {}
- }
-}
-"#,
- );
- }
-
- #[test]
- fn enum_non_exhaustive() {
- check_diagnostics(
- r#"
-//- /lib.rs crate:lib
-#[non_exhaustive]
-pub enum E { A, B }
-fn _local() {
- match E::A { _ => {} }
- match E::A {
- E::A => {}
- E::B => {}
- }
- match E::A {
- E::A | E::B => {}
- }
-}
-
-//- /main.rs crate:main deps:lib
-use lib::E;
-fn main() {
- match E::A { _ => {} }
- match E::A {
- //^^^^ Missing match arm
- E::A => {}
- E::B => {}
- }
- match E::A {
- //^^^^ Missing match arm
- E::A | E::B => {}
- }
-}
-"#,
- );
- }
-
- #[test]
- fn match_guard() {
- check_diagnostics(
- r#"
-fn main() {
- match true {
- true if false => {}
- true => {}
- false => {}
- }
- match true {
- //^^^^ Missing match arm
- true if false => {}
- false => {}
- }
-}
-"#,
- );
- }
-
- #[test]
- fn pattern_type_is_of_substitution() {
- check_diagnostics(
- r#"
-struct Foo<T>(T);
-struct Bar;
-fn main() {
- match Foo(Bar) {
- _ | Foo(Bar) => {}
- }
-}
-"#,
- );
- }
-
- #[test]
- fn record_struct_no_such_field() {
- check_diagnostics(
- r#"
-struct Foo { }
-fn main(f: Foo) {
- match f { Foo { bar } => () }
- // ^^^^^^^^^^^ Internal: match check bailed out
-}
-"#,
- );
- }
-
- #[test]
- fn match_ergonomics_issue_9095() {
- check_diagnostics(
- r#"
-enum Foo<T> { A(T) }
-fn main() {
- match &Foo::A(true) {
- _ => {}
- Foo::A(_) => {}
- }
-}
-"#,
- );
- }
-
- mod false_negatives {
- //! The implementation of match checking here is a work in progress. As we roll this out, we
- //! prefer false negatives to false positives (ideally there would be no false positives). This
- //! test module should document known false negatives. Eventually we will have a complete
- //! implementation of match checking and this module will be empty.
- //!
- //! The reasons for documenting known false negatives:
- //!
- //! 1. It acts as a backlog of work that can be done to improve the behavior of the system.
- //! 2. It ensures the code doesn't panic when handling these cases.
- use super::*;
-
- #[test]
- fn integers() {
- // We don't currently check integer exhaustiveness.
- check_diagnostics(
- r#"
-fn main() {
- match 5 {
- 10 => (),
- // ^^ Internal: match check bailed out
- 11..20 => (),
- }
-}
-"#,
- );
- }
-
- #[test]
- fn reference_patterns_at_top_level() {
- check_diagnostics(
- r#"
-fn main() {
- match &false {
- &true => {}
- // ^^^^^ Internal: match check bailed out
- }
-}
- "#,
- );
- }
-
- #[test]
- fn reference_patterns_in_fields() {
- check_diagnostics(
- r#"
-fn main() {
- match (&false,) {
- (true,) => {}
- // ^^^^^^^ Internal: match check bailed out
- }
- match (&false,) {
- (&true,) => {}
- // ^^^^^^^^ Internal: match check bailed out
- }
-}
- "#,
- );
- }
- }
}
projects / rust.git / blobdiff