luau-syntax 0.732.0

Luau lexer, parser, AST, CST, and source utilities
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
68
69
70
71
72

use super::super::common::*;

// Parser.test.cpp: generic_pack_parsing
#[test]
fn generic_pack_parsing() {
    with_parse(
        r#"
function f<a...>(...: a...)
end

type A = (a...) -> b...
"#,
        ParseOptions::default(),
        |result| {
            let result = result.unwrap();

            let [source_function, ty] = statement_kinds(result.root.as_slice()).exact();
            let source_function = source_function
                .as_function_declaration()
                .expect("expected function declaration")
                .function;
            let ty = ty.as_type_alias().expect("expected type alias").ty;
            let TypeKind::Function {
                arg_types,
                return_types,
                ..
            } = ty.kind()
            else {
                panic!("expected function type alias");
            };

            assert!(matches!(
                source_function.vararg_annotation.map(|annotation| annotation.kind()),
                Some(TypePackKind::Generic { generic_name: name, .. }) if name == "a"
            ));
            assert!(
                matches!(arg_types, TypeList { types, tail_type: Some(tail) } if types.is_empty() && matches!(&tail.kind(), TypePackKind::Generic { generic_name: name, .. } if name == "a")
                )
            );
            assert!(
                matches!(&return_types.kind(), TypePackKind::Generic { generic_name: name, .. } if name == "b"
                )
            );
        },
    );
}
// Parser.test.cpp: generic_function_declaration_parsing
#[test]
fn generic_function_declaration_parsing() {
    with_parse_ok_with_declarations("declare function f<a, b, c...>()", |result| {
        let [statement] = statement_kinds(result.root.as_slice()).exact();
        let declaration = statement
            .as_declare_function()
            .expect("expected generic function declaration");

        assert_eq!(declaration.generics.len(), 2);
        assert_eq!(declaration.generic_packs.len(), 1);
    });
}
// Parser.test.cpp: parse_type_pack_type_parameters
#[test]
fn parse_type_pack_type_parameters() {
    parse_ok(
        r#"
type Packed<T...> = () -> T...

type A<X...> = Packed<X...>
type B<X...> = Packed<...number>
type C<X...> = Packed<(number, X...)>
"#,
    );
}