Merge #5363

5363: Reduce visibility r=matklad a=matklad bors r+ 🤖 Co-authored-by: Aleksey Kladov <[email protected]>
author: bors[bot] <26634292+bors[bot]@users.noreply.github.com> 2020-07-14 10:10:46 +0100
committer: GitHub <[email protected]> 2020-07-14 10:10:46 +0100
commit: d7fee60507ee0a0c67fb42fd7e8466d1a308e010 (patch)
tree: 73803d742edeb6a0f31d09817ffb6e89852bb2f5 /crates
parent: 45ec95caf616e721ca9f876740e65b9591aa5faf (diff)
parent: 7b2ce1a54f75ba5d933521ba8780aaf1ffeef407 (diff)
1 files changed, 83 insertions, 85 deletions
diff --git a/crates/ra_hir_ty/src/diagnostics/match_check.rs b/crates/ra_hir_ty/src/diagnostics/match_check.rs
index 722c0e9ee..899025a87 100644
--- a/crates/ra_hir_ty/src/diagnostics/match_check.rs
+++ b/crates/ra_hir_ty/src/diagnostics/match_check.rs
@@ -272,7 +272,7 @@ impl From<&PatId> for PatIdOrWild {
 }
 #[derive(Debug, Clone, Copy, PartialEq)]
-pub enum MatchCheckErr {
+pub(super) enum MatchCheckErr {
    NotImplemented,
    MalformedMatchArm,
    /// Used when type inference cannot resolve the type of
@@ -287,21 +287,21 @@ pub enum MatchCheckErr {
 ///
 /// The `std::result::Result` type is used here rather than a custom enum
 /// to allow the use of `?`.
-pub type MatchCheckResult<T> = Result<T, MatchCheckErr>;
+pub(super) type MatchCheckResult<T> = Result<T, MatchCheckErr>;
 #[derive(Debug)]
 /// A row in a Matrix.
 ///
 /// This type is modeled from the struct of the same name in `rustc`.
-pub(crate) struct PatStack(PatStackInner);
+pub(super) struct PatStack(PatStackInner);
 type PatStackInner = SmallVec<[PatIdOrWild; 2]>;
 impl PatStack {
-    pub(crate) fn from_pattern(pat_id: PatId) -> PatStack {
+    pub(super) fn from_pattern(pat_id: PatId) -> PatStack {
        Self(smallvec!(pat_id.into()))
    }
-    pub(crate) fn from_wild() -> PatStack {
+    pub(super) fn from_wild() -> PatStack {
        Self(smallvec!(PatIdOrWild::Wild))
    }
@@ -510,14 +510,14 @@ impl PatStack {
 /// A collection of PatStack.
 ///
 /// This type is modeled from the struct of the same name in `rustc`.
-pub(crate) struct Matrix(Vec<PatStack>);
+pub(super) struct Matrix(Vec<PatStack>);
 impl Matrix {
-    pub(crate) fn empty() -> Self {
+    pub(super) fn empty() -> Self {
        Self(vec![])
    }
-    pub(crate) fn push(&mut self, cx: &MatchCheckCtx, row: PatStack) {
+    pub(super) fn push(&mut self, cx: &MatchCheckCtx, row: PatStack) {
        if let Some(Pat::Or(pat_ids)) = row.get_head().map(|pat_id| pat_id.as_pat(cx)) {
            // Or patterns are expanded here
            for pat_id in pat_ids {
@@ -579,16 +579,16 @@ impl Matrix {
 /// not matched by an prior match arms.
 ///
 /// We may eventually need an `Unknown` variant here.
-pub enum Usefulness {
+pub(super) enum Usefulness {
    Useful,
    NotUseful,
 }
-pub struct MatchCheckCtx<'a> {
+pub(super) struct MatchCheckCtx<'a> {
-    pub match_expr: Idx<Expr>,
+    pub(super) match_expr: Idx<Expr>,
-    pub body: Arc<Body>,
+    pub(super) body: Arc<Body>,
-    pub infer: Arc<InferenceResult>,
+    pub(super) infer: Arc<InferenceResult>,
-    pub db: &'a dyn HirDatabase,
+    pub(super) db: &'a dyn HirDatabase,
 }
 /// Given a set of patterns `matrix`, and pattern to consider `v`, determines
@@ -599,7 +599,7 @@ pub struct MatchCheckCtx<'a> {
 /// expected that you have already type checked the match arms. All patterns in
 /// matrix should be the same type as v, as well as they should all be the same
 /// type as the match expression.
-pub(crate) fn is_useful(
+pub(super) fn is_useful(
    cx: &MatchCheckCtx,
    matrix: &Matrix,
    v: &PatStack,
@@ -837,23 +837,23 @@ fn enum_variant_matches(cx: &MatchCheckCtx, pat_id: PatId, enum_variant_id: Enum
 #[cfg(test)]
 mod tests {
-    pub(super) use insta::assert_snapshot;
+    use insta::assert_snapshot;
-    pub(super) use ra_db::fixture::WithFixture;
+    use ra_db::fixture::WithFixture;
-    pub(super) use crate::{diagnostics::MissingMatchArms, test_db::TestDB};
+    use crate::{diagnostics::MissingMatchArms, test_db::TestDB};
-    pub(super) fn check_diagnostic_message(ra_fixture: &str) -> String {
+    fn check_diagnostic_message(ra_fixture: &str) -> String {
        TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().0
    }
-    pub(super) fn check_diagnostic(ra_fixture: &str) {
+    fn check_diagnostic(ra_fixture: &str) {
        let diagnostic_count =
            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
        assert_eq!(1, diagnostic_count, "no diagnostic reported");
    }
-    pub(super) fn check_no_diagnostic(ra_fixture: &str) {
+    fn check_no_diagnostic(ra_fixture: &str) {
        let (s, diagnostic_count) =
            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>();
@@ -2036,28 +2036,25 @@ mod tests {
        ",
        );
    }
-}
-#[cfg(test)]
+    mod false_negatives {
-mod false_negatives {
+        //! The implementation of match checking here is a work in progress. As we roll this out, we
-    //! 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
-    //! 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
-    //! test module should document known false negatives. Eventually we will have a complete
+        //! implementation of match checking and this module will be empty.
-    //! implementation of match checking and this module will be empty.
+        //!
-    //!
+        //! The reasons for documenting known false negatives:
-    //! 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.
-    //!   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.
-    //!   2. It ensures the code doesn't panic when handling these cases.
+        use super::*;
-    use super::tests::*;
+        #[test]
+        fn integers() {
-    #[test]
+            // This is a false negative.
-    fn integers() {
+            // We don't currently check integer exhaustiveness.
-        // This is a false negative.
+            check_no_diagnostic(
-        // We don't currently check integer exhaustiveness.
+                r"
-        check_no_diagnostic(
-            r"
            fn test_fn() {
                match 5 {
                    10 => (),
@@ -2065,15 +2062,15 @@ mod false_negatives {
                }
            }
        ",
-        );
+            );
-    }
+        }
-    #[test]
+        #[test]
-    fn internal_or() {
+        fn internal_or() {
-        // This is a false negative.
+            // This is a false negative.
-        // We do not currently handle patterns with internal `or`s.
+            // We do not currently handle patterns with internal `or`s.
-        check_no_diagnostic(
+            check_no_diagnostic(
-            r"
+                r"
            fn test_fn() {
                enum Either {
                    A(bool),
@@ -2084,17 +2081,17 @@ mod false_negatives {
                }
            }
        ",
-        );
+            );
-    }
+        }
-    #[test]
+        #[test]
-    fn expr_loop_missing_arm() {
+        fn expr_loop_missing_arm() {
-        // This is a false negative.
+            // This is a false negative.
-        // We currently infer the type of `loop { break Foo::A }` to `!`, which
+            // We currently infer the type of `loop { break Foo::A }` to `!`, which
-        // causes us to skip the diagnostic since `Either::A` doesn't type check
+            // causes us to skip the diagnostic since `Either::A` doesn't type check
-        // with `!`.
+            // with `!`.
-        check_diagnostic(
+            check_diagnostic(
-            r"
+                r"
            enum Either {
                A,
                B,
@@ -2105,45 +2102,45 @@ mod false_negatives {
                }
            }
        ",
-        );
+            );
-    }
+        }
-    #[test]
+        #[test]
-    fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
+        fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
-        // This is a false negative.
+            // This is a false negative.
-        // We don't currently handle tuple patterns with ellipsis.
+            // We don't currently handle tuple patterns with ellipsis.
-        check_no_diagnostic(
+            check_no_diagnostic(
-            r"
+                r"
            fn test_fn() {
                match (false, true, false) {
                    (false, ..) => {},
                }
            }
        ",
-        );
+            );
-    }
+        }
-    #[test]
+        #[test]
-    fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
+        fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
-        // This is a false negative.
+            // This is a false negative.
-        // We don't currently handle tuple patterns with ellipsis.
+            // We don't currently handle tuple patterns with ellipsis.
-        check_no_diagnostic(
+            check_no_diagnostic(
-            r"
+                r"
            fn test_fn() {
                match (false, true, false) {
                    (.., false) => {},
                }
            }
        ",
-        );
+            );
-    }
+        }
-    #[test]
+        #[test]
-    fn struct_missing_arm() {
+        fn struct_missing_arm() {
-        // This is a false negative.
+            // This is a false negative.
-        // We don't currently handle structs.
+            // We don't currently handle structs.
-        check_no_diagnostic(
+            check_no_diagnostic(
-            r"
+                r"
            struct Foo {
                a: bool,
            }
@@ -2153,6 +2150,7 @@ mod false_negatives {
                }
            }
        ",
-        );
+            );
+        }
    }
 }
author	bors[bot] <26634292+bors[bot]@users.noreply.github.com>	2020-07-14 10:10:46 +0100
committer	GitHub <[email protected]>	2020-07-14 10:10:46 +0100
commit	d7fee60507ee0a0c67fb42fd7e8466d1a308e010 (patch)
tree	73803d742edeb6a0f31d09817ffb6e89852bb2f5 /crates
parent	45ec95caf616e721ca9f876740e65b9591aa5faf (diff)
parent	7b2ce1a54f75ba5d933521ba8780aaf1ffeef407 (diff)

diff --git a/crates/ra_hir_ty/src/diagnostics/match_check.rs b/crates/ra_hir_ty/src/diagnostics/match_check.rs index 722c0e9ee..899025a87 100644 --- a/crates/ra_hir_ty/src/diagnostics/match_check.rs +++ b/crates/ra_hir_ty/src/diagnostics/match_check.rs
@@ -272,7 +272,7 @@ impl From<&PatId> for PatIdOrWild {
272	}	272	}
273		273
274	#[derive(Debug, Clone, Copy, PartialEq)]	274	#[derive(Debug, Clone, Copy, PartialEq)]
275	pub enum MatchCheckErr {	275	pub(super) enum MatchCheckErr {
276	NotImplemented,	276	NotImplemented,
277	MalformedMatchArm,	277	MalformedMatchArm,
278	/// Used when type inference cannot resolve the type of	278	/// Used when type inference cannot resolve the type of
@@ -287,21 +287,21 @@ pub enum MatchCheckErr {
287	///	287	///
288	/// The `std::result::Result` type is used here rather than a custom enum	288	/// The `std::result::Result` type is used here rather than a custom enum
289	/// to allow the use of `?`.	289	/// to allow the use of `?`.
290	pub type MatchCheckResult<T> = Result<T, MatchCheckErr>;	290	pub(super) type MatchCheckResult<T> = Result<T, MatchCheckErr>;
291		291
292	#[derive(Debug)]	292	#[derive(Debug)]
293	/// A row in a Matrix.	293	/// A row in a Matrix.
294	///	294	///
295	/// This type is modeled from the struct of the same name in `rustc`.	295	/// This type is modeled from the struct of the same name in `rustc`.
296	pub(crate) struct PatStack(PatStackInner);	296	pub(super) struct PatStack(PatStackInner);
297	type PatStackInner = SmallVec<[PatIdOrWild; 2]>;	297	type PatStackInner = SmallVec<[PatIdOrWild; 2]>;
298		298
299	impl PatStack {	299	impl PatStack {
300	pub(crate) fn from_pattern(pat_id: PatId) -> PatStack {	300	pub(super) fn from_pattern(pat_id: PatId) -> PatStack {
301	Self(smallvec!(pat_id.into()))	301	Self(smallvec!(pat_id.into()))
302	}	302	}
303		303
304	pub(crate) fn from_wild() -> PatStack {	304	pub(super) fn from_wild() -> PatStack {
305	Self(smallvec!(PatIdOrWild::Wild))	305	Self(smallvec!(PatIdOrWild::Wild))
306	}	306	}
307		307
@@ -510,14 +510,14 @@ impl PatStack {
510	/// A collection of PatStack.	510	/// A collection of PatStack.
511	///	511	///
512	/// This type is modeled from the struct of the same name in `rustc`.	512	/// This type is modeled from the struct of the same name in `rustc`.
513	pub(crate) struct Matrix(Vec<PatStack>);	513	pub(super) struct Matrix(Vec<PatStack>);
514		514
515	impl Matrix {	515	impl Matrix {
516	pub(crate) fn empty() -> Self {	516	pub(super) fn empty() -> Self {
517	Self(vec![])	517	Self(vec![])
518	}	518	}
519		519
520	pub(crate) fn push(&mut self, cx: &MatchCheckCtx, row: PatStack) {	520	pub(super) fn push(&mut self, cx: &MatchCheckCtx, row: PatStack) {
521	if let Some(Pat::Or(pat_ids)) = row.get_head().map(\|pat_id\| pat_id.as_pat(cx)) {	521	if let Some(Pat::Or(pat_ids)) = row.get_head().map(\|pat_id\| pat_id.as_pat(cx)) {
522	// Or patterns are expanded here	522	// Or patterns are expanded here
523	for pat_id in pat_ids {	523	for pat_id in pat_ids {
@@ -579,16 +579,16 @@ impl Matrix {
579	/// not matched by an prior match arms.	579	/// not matched by an prior match arms.
580	///	580	///
581	/// We may eventually need an `Unknown` variant here.	581	/// We may eventually need an `Unknown` variant here.
582	pub enum Usefulness {	582	pub(super) enum Usefulness {
583	Useful,	583	Useful,
584	NotUseful,	584	NotUseful,
585	}	585	}
586		586
587	pub struct MatchCheckCtx<'a> {	587	pub(super) struct MatchCheckCtx<'a> {
588	pub match_expr: Idx<Expr>,	588	pub(super) match_expr: Idx<Expr>,
589	pub body: Arc<Body>,	589	pub(super) body: Arc<Body>,
590	pub infer: Arc<InferenceResult>,	590	pub(super) infer: Arc<InferenceResult>,
591	pub db: &'a dyn HirDatabase,	591	pub(super) db: &'a dyn HirDatabase,
592	}	592	}
593		593
594	/// Given a set of patterns `matrix`, and pattern to consider `v`, determines	594	/// Given a set of patterns `matrix`, and pattern to consider `v`, determines
@@ -599,7 +599,7 @@ pub struct MatchCheckCtx<'a> {
599	/// expected that you have already type checked the match arms. All patterns in	599	/// expected that you have already type checked the match arms. All patterns in
600	/// matrix should be the same type as v, as well as they should all be the same	600	/// matrix should be the same type as v, as well as they should all be the same
601	/// type as the match expression.	601	/// type as the match expression.
602	pub(crate) fn is_useful(	602	pub(super) fn is_useful(
603	cx: &MatchCheckCtx,	603	cx: &MatchCheckCtx,
604	matrix: &Matrix,	604	matrix: &Matrix,
605	v: &PatStack,	605	v: &PatStack,
@@ -837,23 +837,23 @@ fn enum_variant_matches(cx: &MatchCheckCtx, pat_id: PatId, enum_variant_id: Enum
837		837
838	#[cfg(test)]	838	#[cfg(test)]
839	mod tests {	839	mod tests {
840	pub(super) use insta::assert_snapshot;	840	use insta::assert_snapshot;
841	pub(super) use ra_db::fixture::WithFixture;	841	use ra_db::fixture::WithFixture;
842		842
843	pub(super) use crate::{diagnostics::MissingMatchArms, test_db::TestDB};	843	use crate::{diagnostics::MissingMatchArms, test_db::TestDB};
844		844
845	pub(super) fn check_diagnostic_message(ra_fixture: &str) -> String {	845	fn check_diagnostic_message(ra_fixture: &str) -> String {
846	TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().0	846	TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().0
847	}	847	}
848		848
849	pub(super) fn check_diagnostic(ra_fixture: &str) {	849	fn check_diagnostic(ra_fixture: &str) {
850	let diagnostic_count =	850	let diagnostic_count =
851	TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;	851	TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
852		852
853	assert_eq!(1, diagnostic_count, "no diagnostic reported");	853	assert_eq!(1, diagnostic_count, "no diagnostic reported");
854	}	854	}
855		855
856	pub(super) fn check_no_diagnostic(ra_fixture: &str) {	856	fn check_no_diagnostic(ra_fixture: &str) {
857	let (s, diagnostic_count) =	857	let (s, diagnostic_count) =
858	TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>();	858	TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>();
859		859
@@ -2036,28 +2036,25 @@ mod tests {
2036	",	2036	",
2037	);	2037	);
2038	}	2038	}
2039	}
2040		2039
2041	#[cfg(test)]	2040	mod false_negatives {
2042	mod false_negatives {	2041	//! The implementation of match checking here is a work in progress. As we roll this out, we
2043	//! The implementation of match checking here is a work in progress. As we roll this out, we	2042	//! prefer false negatives to false positives (ideally there would be no false positives). This
2044	//! prefer false negatives to false positives (ideally there would be no false positives). This	2043	//! test module should document known false negatives. Eventually we will have a complete
2045	//! test module should document known false negatives. Eventually we will have a complete	2044	//! implementation of match checking and this module will be empty.
2046	//! implementation of match checking and this module will be empty.	2045	//!
2047	//!	2046	//! The reasons for documenting known false negatives:
2048	//! The reasons for documenting known false negatives:	2047	//!
2049	//!	2048	//! 1. It acts as a backlog of work that can be done to improve the behavior of the system.
2050	//! 1. It acts as a backlog of work that can be done to improve the behavior of the system.	2049	//! 2. It ensures the code doesn't panic when handling these cases.
2051	//! 2. It ensures the code doesn't panic when handling these cases.	2050	use super::*;
2052		2051
2053	use super::tests::*;	2052	#[test]
2054		2053	fn integers() {
2055	#[test]	2054	// This is a false negative.
2056	fn integers() {	2055	// We don't currently check integer exhaustiveness.
2057	// This is a false negative.	2056	check_no_diagnostic(
2058	// We don't currently check integer exhaustiveness.	2057	r"
2059	check_no_diagnostic(
2060	r"
2061	fn test_fn() {	2058	fn test_fn() {
2062	match 5 {	2059	match 5 {
2063	10 => (),	2060	10 => (),
@@ -2065,15 +2062,15 @@ mod false_negatives {
2065	}	2062	}
2066	}	2063	}
2067	",	2064	",
2068	);	2065	);
2069	}	2066	}
2070		2067
2071	#[test]	2068	#[test]
2072	fn internal_or() {	2069	fn internal_or() {
2073	// This is a false negative.	2070	// This is a false negative.
2074	// We do not currently handle patterns with internal `or`s.	2071	// We do not currently handle patterns with internal `or`s.
2075	check_no_diagnostic(	2072	check_no_diagnostic(
2076	r"	2073	r"
2077	fn test_fn() {	2074	fn test_fn() {
2078	enum Either {	2075	enum Either {
2079	A(bool),	2076	A(bool),
@@ -2084,17 +2081,17 @@ mod false_negatives {
2084	}	2081	}
2085	}	2082	}
2086	",	2083	",
2087	);	2084	);
2088	}	2085	}
2089		2086
2090	#[test]	2087	#[test]
2091	fn expr_loop_missing_arm() {	2088	fn expr_loop_missing_arm() {
2092	// This is a false negative.	2089	// This is a false negative.
2093	// We currently infer the type of `loop { break Foo::A }` to `!`, which	2090	// We currently infer the type of `loop { break Foo::A }` to `!`, which
2094	// causes us to skip the diagnostic since `Either::A` doesn't type check	2091	// causes us to skip the diagnostic since `Either::A` doesn't type check
2095	// with `!`.	2092	// with `!`.
2096	check_diagnostic(	2093	check_diagnostic(
2097	r"	2094	r"
2098	enum Either {	2095	enum Either {
2099	A,	2096	A,
2100	B,	2097	B,
@@ -2105,45 +2102,45 @@ mod false_negatives {
2105	}	2102	}
2106	}	2103	}
2107	",	2104	",
2108	);	2105	);
2109	}	2106	}
2110		2107
2111	#[test]	2108	#[test]
2112	fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {	2109	fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
2113	// This is a false negative.	2110	// This is a false negative.
2114	// We don't currently handle tuple patterns with ellipsis.	2111	// We don't currently handle tuple patterns with ellipsis.
2115	check_no_diagnostic(	2112	check_no_diagnostic(
2116	r"	2113	r"
2117	fn test_fn() {	2114	fn test_fn() {
2118	match (false, true, false) {	2115	match (false, true, false) {
2119	(false, ..) => {},	2116	(false, ..) => {},
2120	}	2117	}
2121	}	2118	}
2122	",	2119	",
2123	);	2120	);
2124	}	2121	}
2125		2122
2126	#[test]	2123	#[test]
2127	fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {	2124	fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
2128	// This is a false negative.	2125	// This is a false negative.
2129	// We don't currently handle tuple patterns with ellipsis.	2126	// We don't currently handle tuple patterns with ellipsis.
2130	check_no_diagnostic(	2127	check_no_diagnostic(
2131	r"	2128	r"
2132	fn test_fn() {	2129	fn test_fn() {
2133	match (false, true, false) {	2130	match (false, true, false) {
2134	(.., false) => {},	2131	(.., false) => {},
2135	}	2132	}
2136	}	2133	}
2137	",	2134	",
2138	);	2135	);
2139	}	2136	}
2140		2137
2141	#[test]	2138	#[test]
2142	fn struct_missing_arm() {	2139	fn struct_missing_arm() {
2143	// This is a false negative.	2140	// This is a false negative.
2144	// We don't currently handle structs.	2141	// We don't currently handle structs.
2145	check_no_diagnostic(	2142	check_no_diagnostic(
2146	r"	2143	r"
2147	struct Foo {	2144	struct Foo {
2148	a: bool,	2145	a: bool,
2149	}	2146	}
@@ -2153,6 +2150,7 @@ mod false_negatives {
2153	}	2150	}
2154	}	2151	}
2155	",	2152	",
2156	);	2153	);
		2154	}
2157	}	2155	}
2158	}	2156	}