libsyntax: Unconfigure tests during normal build

3 files changed, 61 insertions, 217 deletions

diff --git a/src/libsyntax/util/lev_distance.rs b/src/libsyntax/util/lev_distance.rs
index 885b5a4f333..4127a8c7fce 100644
--- a/src/libsyntax/util/lev_distance.rs
+++ b/src/libsyntax/util/lev_distance.rs
@@ -1,6 +1,9 @@
 use std::cmp;
 use crate::symbol::Symbol;
 
+#[cfg(test)]
+mod tests;
+
 /// Finds the Levenshtein distance between two strings
 pub fn lev_distance(a: &str, b: &str) -> usize {
     // cases which don't require further computation
@@ -77,60 +80,3 @@ pub fn find_best_match_for_name<'a, T>(iter_names: T,
         if let Some((candidate, _)) = levenstein_match { Some(candidate) } else { None }
     }
 }
-
-#[test]
-fn test_lev_distance() {
-    use std::char::{from_u32, MAX};
-    // Test bytelength agnosticity
-    for c in (0..MAX as u32)
-             .filter_map(|i| from_u32(i))
-             .map(|i| i.to_string()) {
-        assert_eq!(lev_distance(&c[..], &c[..]), 0);
-    }
-
-    let a = "\nMäry häd ä little lämb\n\nLittle lämb\n";
-    let b = "\nMary häd ä little lämb\n\nLittle lämb\n";
-    let c = "Mary häd ä little lämb\n\nLittle lämb\n";
-    assert_eq!(lev_distance(a, b), 1);
-    assert_eq!(lev_distance(b, a), 1);
-    assert_eq!(lev_distance(a, c), 2);
-    assert_eq!(lev_distance(c, a), 2);
-    assert_eq!(lev_distance(b, c), 1);
-    assert_eq!(lev_distance(c, b), 1);
-}
-
-#[test]
-fn test_find_best_match_for_name() {
-    use crate::with_default_globals;
-    with_default_globals(|| {
-        let input = vec![Symbol::intern("aaab"), Symbol::intern("aaabc")];
-        assert_eq!(
-            find_best_match_for_name(input.iter(), "aaaa", None),
-            Some(Symbol::intern("aaab"))
-        );
-
-        assert_eq!(
-            find_best_match_for_name(input.iter(), "1111111111", None),
-            None
-        );
-
-        let input = vec![Symbol::intern("aAAA")];
-        assert_eq!(
-            find_best_match_for_name(input.iter(), "AAAA", None),
-            Some(Symbol::intern("aAAA"))
-        );
-
-        let input = vec![Symbol::intern("AAAA")];
-        // Returns None because `lev_distance > max_dist / 3`
-        assert_eq!(
-            find_best_match_for_name(input.iter(), "aaaa", None),
-            None
-        );
-
-        let input = vec![Symbol::intern("AAAA")];
-        assert_eq!(
-            find_best_match_for_name(input.iter(), "aaaa", Some(4)),
-            Some(Symbol::intern("AAAA"))
-        );
-    })
-}
diff --git a/src/libsyntax/util/lev_distance/tests.rs b/src/libsyntax/util/lev_distance/tests.rs
new file mode 100644
index 00000000000..1a746a67ec0
--- /dev/null
+++ b/src/libsyntax/util/lev_distance/tests.rs
@@ -0,0 +1,58 @@
+use super::*;
+
+#[test]
+fn test_lev_distance() {
+    use std::char::{from_u32, MAX};
+    // Test bytelength agnosticity
+    for c in (0..MAX as u32)
+             .filter_map(|i| from_u32(i))
+             .map(|i| i.to_string()) {
+        assert_eq!(lev_distance(&c[..], &c[..]), 0);
+    }
+
+    let a = "\nMäry häd ä little lämb\n\nLittle lämb\n";
+    let b = "\nMary häd ä little lämb\n\nLittle lämb\n";
+    let c = "Mary häd ä little lämb\n\nLittle lämb\n";
+    assert_eq!(lev_distance(a, b), 1);
+    assert_eq!(lev_distance(b, a), 1);
+    assert_eq!(lev_distance(a, c), 2);
+    assert_eq!(lev_distance(c, a), 2);
+    assert_eq!(lev_distance(b, c), 1);
+    assert_eq!(lev_distance(c, b), 1);
+}
+
+#[test]
+fn test_find_best_match_for_name() {
+    use crate::with_default_globals;
+    with_default_globals(|| {
+        let input = vec![Symbol::intern("aaab"), Symbol::intern("aaabc")];
+        assert_eq!(
+            find_best_match_for_name(input.iter(), "aaaa", None),
+            Some(Symbol::intern("aaab"))
+        );
+
+        assert_eq!(
+            find_best_match_for_name(input.iter(), "1111111111", None),
+            None
+        );
+
+        let input = vec![Symbol::intern("aAAA")];
+        assert_eq!(
+            find_best_match_for_name(input.iter(), "AAAA", None),
+            Some(Symbol::intern("aAAA"))
+        );
+
+        let input = vec![Symbol::intern("AAAA")];
+        // Returns None because `lev_distance > max_dist / 3`
+        assert_eq!(
+            find_best_match_for_name(input.iter(), "aaaa", None),
+            None
+        );
+
+        let input = vec![Symbol::intern("AAAA")];
+        assert_eq!(
+            find_best_match_for_name(input.iter(), "aaaa", Some(4)),
+            Some(Symbol::intern("AAAA"))
+        );
+    })
+}
diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs
deleted file mode 100644
index 627422df1db..00000000000
--- a/src/libsyntax/util/parser_testing.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-use crate::ast::{self, Ident};
-use crate::source_map::FilePathMapping;
-use crate::parse::{ParseSess, PResult, source_file_to_stream};
-use crate::parse::new_parser_from_source_str;
-use crate::parse::parser::Parser;
-use crate::ptr::P;
-use crate::tokenstream::TokenStream;
-
-use std::iter::Peekable;
-use std::path::PathBuf;
-
-/// Map a string to tts, using a made-up filename:
-pub fn string_to_stream(source_str: String) -> TokenStream {
-    let ps = ParseSess::new(FilePathMapping::empty());
-    source_file_to_stream(
-        &ps,
-        ps.source_map().new_source_file(PathBuf::from("bogofile").into(),
-        source_str,
-    ), None).0
-}
-
-/// Map string to parser (via tts)
-pub fn string_to_parser(ps: &ParseSess, source_str: String) -> Parser<'_> {
-    new_parser_from_source_str(ps, PathBuf::from("bogofile").into(), source_str)
-}
-
-fn with_error_checking_parse<'a, T, F>(s: String, ps: &'a ParseSess, f: F) -> T where
-    F: FnOnce(&mut Parser<'a>) -> PResult<'a, T>,
-{
-    let mut p = string_to_parser(&ps, s);
-    let x = panictry!(f(&mut p));
-    p.sess.span_diagnostic.abort_if_errors();
-    x
-}
-
-/// Parse a string, return a crate.
-pub fn string_to_crate(source_str : String) -> ast::Crate {
-    let ps = ParseSess::new(FilePathMapping::empty());
-    with_error_checking_parse(source_str, &ps, |p| {
-        p.parse_crate_mod()
-    })
-}
-
-/// Parse a string, return an expr
-pub fn string_to_expr(source_str : String) -> P<ast::Expr> {
-    let ps = ParseSess::new(FilePathMapping::empty());
-    with_error_checking_parse(source_str, &ps, |p| {
-        p.parse_expr()
-    })
-}
-
-/// Parse a string, return an item
-pub fn string_to_item(source_str : String) -> Option<P<ast::Item>> {
-    let ps = ParseSess::new(FilePathMapping::empty());
-    with_error_checking_parse(source_str, &ps, |p| {
-        p.parse_item()
-    })
-}
-
-/// Parse a string, return a pat. Uses "irrefutable"... which doesn't
-/// (currently) affect parsing.
-pub fn string_to_pat(source_str: String) -> P<ast::Pat> {
-    let ps = ParseSess::new(FilePathMapping::empty());
-    with_error_checking_parse(source_str, &ps, |p| {
-        p.parse_pat(None)
-    })
-}
-
-/// Converts a vector of strings to a vector of Ident's
-pub fn strs_to_idents(ids: Vec<&str> ) -> Vec<Ident> {
-    ids.iter().map(|u| Ident::from_str(*u)).collect()
-}
-
-/// Does the given string match the pattern? whitespace in the first string
-/// may be deleted or replaced with other whitespace to match the pattern.
-/// This function is relatively Unicode-ignorant; fortunately, the careful design
-/// of UTF-8 mitigates this ignorance. It doesn't do NKF-normalization(?).
-pub fn matches_codepattern(a : &str, b : &str) -> bool {
-    let mut a_iter = a.chars().peekable();
-    let mut b_iter = b.chars().peekable();
-
-    loop {
-        let (a, b) = match (a_iter.peek(), b_iter.peek()) {
-            (None, None) => return true,
-            (None, _) => return false,
-            (Some(&a), None) => {
-                if is_pattern_whitespace(a) {
-                    break // trailing whitespace check is out of loop for borrowck
-                } else {
-                    return false
-                }
-            }
-            (Some(&a), Some(&b)) => (a, b)
-        };
-
-        if is_pattern_whitespace(a) && is_pattern_whitespace(b) {
-            // skip whitespace for a and b
-            scan_for_non_ws_or_end(&mut a_iter);
-            scan_for_non_ws_or_end(&mut b_iter);
-        } else if is_pattern_whitespace(a) {
-            // skip whitespace for a
-            scan_for_non_ws_or_end(&mut a_iter);
-        } else if a == b {
-            a_iter.next();
-            b_iter.next();
-        } else {
-            return false
-        }
-    }
-
-    // check if a has *only* trailing whitespace
-    a_iter.all(is_pattern_whitespace)
-}
-
-/// Advances the given peekable `Iterator` until it reaches a non-whitespace character
-fn scan_for_non_ws_or_end<I: Iterator<Item = char>>(iter: &mut Peekable<I>) {
-    while iter.peek().copied().map(|c| is_pattern_whitespace(c)) == Some(true) {
-        iter.next();
-    }
-}
-
-pub fn is_pattern_whitespace(c: char) -> bool {
-    rustc_lexer::character_properties::is_whitespace(c)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn eqmodws() {
-        assert_eq!(matches_codepattern("",""),true);
-        assert_eq!(matches_codepattern("","a"),false);
-        assert_eq!(matches_codepattern("a",""),false);
-        assert_eq!(matches_codepattern("a","a"),true);
-        assert_eq!(matches_codepattern("a b","a   \n\t\r  b"),true);
-        assert_eq!(matches_codepattern("a b ","a   \n\t\r  b"),true);
-        assert_eq!(matches_codepattern("a b","a   \n\t\r  b "),false);
-        assert_eq!(matches_codepattern("a   b","a b"),true);
-        assert_eq!(matches_codepattern("ab","a b"),false);
-        assert_eq!(matches_codepattern("a   b","ab"),true);
-        assert_eq!(matches_codepattern(" a   b","ab"),true);
-    }
-
-    #[test]
-    fn pattern_whitespace() {
-        assert_eq!(matches_codepattern("","\x0C"), false);
-        assert_eq!(matches_codepattern("a b ","a   \u{0085}\n\t\r  b"),true);
-        assert_eq!(matches_codepattern("a b","a   \u{0085}\n\t\r  b "),false);
-    }
-
-    #[test]
-    fn non_pattern_whitespace() {
-        // These have the property 'White_Space' but not 'Pattern_White_Space'
-        assert_eq!(matches_codepattern("a b","a\u{2002}b"), false);
-        assert_eq!(matches_codepattern("a   b","a\u{2002}b"), false);
-        assert_eq!(matches_codepattern("\u{205F}a   b","ab"), false);
-        assert_eq!(matches_codepattern("a  \u{3000}b","ab"), false);
-    }
-}