fallow-core 2.40.0

Core analysis engine for the fallow TypeScript/JavaScript codebase analyzer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use super::*;
use proptest::prelude::*;
use std::path::PathBuf;

#[expect(
    clippy::cast_possible_truncation,
    reason = "test source lengths are trivially small"
)]
mod inner {
    use super::*;

    proptest! {
        /// Tokenizing the same source twice always produces the same token sequence.
        #[test]
        fn tokenize_is_deterministic(source in "[a-zA-Z0-9 (){};=+\\-*/'\",.<>:!?\\n]{1,200}") {
            let path = PathBuf::from("test.ts");
            let tokens1 = tokenize_file(&path, &source, false).tokens;
            let tokens2 = tokenize_file(&path, &source, false).tokens;
            prop_assert_eq!(tokens1.len(), tokens2.len(), "Token count should be deterministic");
            for (a, b) in tokens1.iter().zip(tokens2.iter()) {
                prop_assert_eq!(&a.kind, &b.kind, "Token kinds should match");
                prop_assert_eq!(a.span.start, b.span.start, "Span starts should match");
                prop_assert_eq!(a.span.end, b.span.end, "Span ends should match");
            }
        }

        /// All token spans must be within source byte bounds.
        #[test]
        fn all_spans_within_source_bounds(source in "[a-zA-Z0-9 (){};=+\\-*/'\",.<>:!?\\n]{1,200}") {
            let path = PathBuf::from("test.ts");
            let file_tokens = tokenize_file(&path, &source, false);
            let source_len = file_tokens.source.len() as u32;
            for token in &file_tokens.tokens {
                prop_assert!(
                    token.span.start <= source_len,
                    "Span start {} exceeds source length {}",
                    token.span.start, source_len
                );
                prop_assert!(
                    token.span.end <= source_len,
                    "Span end {} exceeds source length {}",
                    token.span.end, source_len
                );
                prop_assert!(
                    token.span.start <= token.span.end,
                    "Span start {} > end {}",
                    token.span.start, token.span.end
                );
            }
        }

        /// Tokenizing never panics on arbitrary JS-like input.
        #[test]
        fn tokenize_never_panics(source in "[a-zA-Z0-9 (){};=+\\-*/'\",.<>:!?\\[\\]\\n]{0,300}") {
            let path = PathBuf::from("test.ts");
            let _ = tokenize_file(&path, &source, false);
        }

        /// Line count is always >= 1.
        #[test]
        fn line_count_at_least_one(source in ".*") {
            let path = PathBuf::from("test.ts");
            let ft = tokenize_file(&path, &source, false);
            prop_assert!(ft.line_count >= 1, "line_count should be at least 1");
        }
    }
}