fluidattacks-blends-domain 0.5.0

Blends functional core: pure AST graph to syntax graph (no_std)
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use crate::syntax::readers::{javascript, typescript};
use crate::syntax::SyntaxReader;

#[must_use]
#[allow(clippy::too_many_lines, reason = "flat node-type dispatch table")]
pub fn dispatcher(node_type: &str) -> Option<SyntaxReader> {
    match node_type {
        "ambient_declaration" => Some(typescript::ambient_declaration::reader),
        "null" | "undefined" => Some(typescript::void::reader),
        "array" => Some(javascript::array_node::reader),
        "array_type" | "literal_type" | "optional_type" | "predefined_type" => {
            Some(typescript::predefined_type::reader)
        }
        "as_expression" => Some(typescript::as_expression::reader),
        "assignment_expression" | "augmented_assignment_expression" => {
            Some(javascript::assignment_expression::reader)
        }
        "await_expression" => Some(javascript::await_expression::reader),
        "binary_expression" => Some(javascript::binary_expression::reader),
        "boolean" | "false" | "true" => Some(javascript::boolean_literal::reader),
        "break_statement" => Some(javascript::break_statement::reader),
        "catch_clause" => Some(javascript::catch_clause::reader),
        "comment" => Some(javascript::comment::reader),
        "decorator" => Some(javascript::decorator::reader),
        "empty_statement" => Some(typescript::empty_statement::reader),
        "enum_assignment" => Some(typescript::enum_assignment::reader),
        "enum_body" => Some(typescript::enum_body::reader),
        "enum_declaration" => Some(typescript::enum_declaration::reader),
        "expression_statement" => Some(javascript::expression_statement::reader),
        "finally_clause" => Some(javascript::finally_clause::reader),
        "function_signature" => Some(typescript::function_signature::reader),
        "function_type" => Some(typescript::function_type::reader),
        "generic_type" => Some(typescript::generic_type::reader),
        "identifier"
        | "property_identifier"
        | "shorthand_property_identifier"
        | "shorthand_property_identifier_pattern"
        | "type_identifier" => Some(javascript::identifier::reader),
        "import_specifier" => Some(javascript::import_module::reader),
        "import_statement" => Some(javascript::import_global::reader),
        "index_signature" => Some(typescript::index_signature::reader),
        "interface_declaration" => Some(typescript::interface_declaration::reader),
        "internal_module" => Some(typescript::internal_module::reader),
        "intersection_type" => Some(typescript::intersection_type::reader),
        "jsx_element" | "jsx_opening_element" => Some(javascript::jsx_element::reader),
        "jsx_self_closing_element" => Some(javascript::jsx_self_closing_element::reader),
        "member_expression" => Some(javascript::member_expression::reader),
        "nested_identifier" => Some(javascript::nested_identifier::reader),
        "new_expression" => Some(javascript::new_expression::reader),
        "number" => Some(javascript::number_literal::reader),
        "parenthesized_expression" => Some(javascript::parenthesized_expression::reader),
        "parenthesized_type" => Some(typescript::parenthesized_type::reader),
        "program" => Some(javascript::program::reader),
        "property_signature" => Some(typescript::property_signature::reader),
        "public_field_definition" => Some(typescript::public_field_definition::reader),
        "regex" | "string" => Some(javascript::string_literal::reader),
        "rest_pattern" => Some(javascript::rest_pattern::reader),
        "return_statement" => Some(javascript::return_statement::reader),
        "spread_element" => Some(javascript::spread_element::reader),
        "subscript_expression" => Some(javascript::subscript_expression::reader),
        "super" | "this" => Some(javascript::this_node::reader),
        "template_string" => Some(javascript::template_string::reader),
        "throw_statement" => Some(javascript::throw_statement::reader),
        "tuple_type" => Some(typescript::tuple_type::reader),
        "type_alias_declaration" => Some(typescript::type_alias_declaration::reader),
        "type_annotation" => Some(typescript::type_annotation::reader),
        "unary_expression" => Some(javascript::unary_expression::reader),
        "union_type" => Some(typescript::union_type::reader),
        "update_expression" => Some(javascript::update_expression::reader),
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::dispatcher;

    #[test]
    fn reuses_the_implemented_javascript_node_types() {
        assert!(dispatcher("program").is_some());
        assert!(dispatcher("comment").is_some());
        assert!(dispatcher("boolean").is_some());
        assert!(dispatcher("true").is_some());
        assert!(dispatcher("false").is_some());
        assert!(dispatcher("number").is_some());
        assert!(dispatcher("string").is_some());
        assert!(dispatcher("regex").is_some());
        assert!(dispatcher("assignment_expression").is_some());
        assert!(dispatcher("augmented_assignment_expression").is_some());
        assert!(dispatcher("await_expression").is_some());
        assert!(dispatcher("binary_expression").is_some());
        assert!(dispatcher("break_statement").is_some());
        assert!(dispatcher("parenthesized_expression").is_some());
        assert!(dispatcher("return_statement").is_some());
        assert!(dispatcher("throw_statement").is_some());
        assert!(dispatcher("unary_expression").is_some());
        assert!(dispatcher("update_expression").is_some());
        assert!(dispatcher("expression_statement").is_some());
        assert!(dispatcher("this").is_some());
        assert!(dispatcher("super").is_some());
        assert!(dispatcher("array").is_some());
        assert!(dispatcher("rest_pattern").is_some());
        assert!(dispatcher("identifier").is_some());
        assert!(dispatcher("property_identifier").is_some());
        assert!(dispatcher("type_identifier").is_some());
        assert!(dispatcher("member_expression").is_some());
        assert!(dispatcher("new_expression").is_some());
        assert!(dispatcher("spread_element").is_some());
        assert!(dispatcher("subscript_expression").is_some());
        assert!(dispatcher("decorator").is_some());
        assert!(dispatcher("nested_identifier").is_some());
        assert!(dispatcher("template_string").is_some());
        assert!(dispatcher("catch_clause").is_some());
        assert!(dispatcher("finally_clause").is_some());
        assert!(dispatcher("import_specifier").is_some());
        assert!(dispatcher("import_statement").is_some());
        assert!(dispatcher("jsx_element").is_some());
        assert!(dispatcher("jsx_opening_element").is_some());
        assert!(dispatcher("jsx_self_closing_element").is_some());
    }

    #[test]
    fn maps_the_migrated_typescript_only_node_types() {
        assert!(dispatcher("as_expression").is_some());
        assert!(dispatcher("function_type").is_some());
        assert!(dispatcher("intersection_type").is_some());
        assert!(dispatcher("union_type").is_some());
        assert!(dispatcher("array_type").is_some());
        assert!(dispatcher("literal_type").is_some());
        assert!(dispatcher("optional_type").is_some());
        assert!(dispatcher("predefined_type").is_some());
        assert!(dispatcher("ambient_declaration").is_some());
        assert!(dispatcher("empty_statement").is_some());
        assert!(dispatcher("generic_type").is_some());
        assert!(dispatcher("internal_module").is_some());
        assert!(dispatcher("parenthesized_type").is_some());
        assert!(dispatcher("type_annotation").is_some());
        assert!(dispatcher("null").is_some());
        assert!(dispatcher("undefined").is_some());
        assert!(dispatcher("enum_assignment").is_some());
        assert!(dispatcher("enum_body").is_some());
        assert!(dispatcher("enum_declaration").is_some());
        assert!(dispatcher("function_signature").is_some());
        assert!(dispatcher("index_signature").is_some());
        assert!(dispatcher("interface_declaration").is_some());
        assert!(dispatcher("property_signature").is_some());
        assert!(dispatcher("public_field_definition").is_some());
        assert!(dispatcher("tuple_type").is_some());
        assert!(dispatcher("type_alias_declaration").is_some());
    }

    #[test]
    fn typescript_only_node_types_are_not_yet_mapped() {
        assert!(dispatcher("arrow_function").is_none());
        assert!(dispatcher("class_body").is_none());
        assert!(dispatcher("ternary_expression").is_none());
        assert!(dispatcher("required_parameter").is_none());
        assert!(dispatcher("optional_parameter").is_none());
        assert!(dispatcher("").is_none());
    }
}