fluidattacks-blends-domain 0.6.1

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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

use crate::syntax::readers::javascript;
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 {
        "arguments" => Some(javascript::arguments::reader),
        "array" => Some(javascript::array_node::reader),
        "arrow_function" => Some(javascript::arrow_function::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),
        "break_statement" => Some(javascript::break_statement::reader),
        "call_expression" => Some(javascript::call_expression::reader),
        "catch_clause" => Some(javascript::catch_clause::reader),
        "class_body" => Some(javascript::class_body::reader),
        "class_declaration" => Some(javascript::class_declaration::reader),
        "comment" => Some(javascript::comment::reader),
        "debugger_statement" => Some(javascript::debugger_statement::reader),
        "decorator" => Some(javascript::decorator::reader),
        "do_statement" => Some(javascript::do_statement::reader),
        "else_clause" => Some(javascript::else_clause::reader),
        "export_statement" => Some(javascript::export_statement::reader),
        "expression_statement" => Some(javascript::expression_statement::reader),
        "false" | "true" => Some(javascript::boolean_literal::reader),
        "field_definition" => Some(javascript::field_definition::reader),
        "finally_clause" => Some(javascript::finally_clause::reader),
        "for_in_statement" => Some(javascript::for_each_statement::reader),
        "for_statement" => Some(javascript::for_statement::reader),
        "formal_parameters" => Some(javascript::parameter_list::reader),
        "function"
        | "function_declaration"
        | "function_expression"
        | "generator_function_declaration"
        | "method_definition" => Some(javascript::method_declaration::reader),
        "if_statement" => Some(javascript::if_statement::reader),
        "identifier"
        | "property_identifier"
        | "shorthand_property_identifier"
        | "shorthand_property_identifier_pattern" => Some(javascript::identifier::reader),
        "import" => Some(javascript::import_node::reader),
        "import_specifier" => Some(javascript::import_module::reader),
        "import_statement" => Some(javascript::import_global::reader),
        "jsx_attribute" => Some(javascript::jsx_attribute::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),
        "new_expression" => Some(javascript::new_expression::reader),
        "null" => Some(javascript::null_literal::reader),
        "number" => Some(javascript::number_literal::reader),
        "object" | "object_pattern" => Some(javascript::object::reader),
        "pair" | "pair_pattern" => Some(javascript::pair::reader),
        "parenthesized_expression" => Some(javascript::parenthesized_expression::reader),
        "program" => Some(javascript::program::reader),
        "regex" | "string" | "undefined" => 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),
        "statement_block" => Some(javascript::execution_block::reader),
        "subscript_expression" => Some(javascript::subscript_expression::reader),
        "switch_body" => Some(javascript::switch_body::reader),
        "switch_case" | "switch_default" => Some(javascript::switch_section::reader),
        "switch_statement" => Some(javascript::switch_statement::reader),
        "template_string" => Some(javascript::template_string::reader),
        "ternary_expression" => Some(javascript::ternary_expression::reader),
        "this" => Some(javascript::this_node::reader),
        "throw_statement" => Some(javascript::throw_statement::reader),
        "try_statement" => Some(javascript::try_statement::reader),
        "unary_expression" => Some(javascript::unary_expression::reader),
        "update_expression" => Some(javascript::update_expression::reader),
        "lexical_declaration" | "variable_declaration" => {
            Some(javascript::variable_declaration::reader)
        }
        "variable_declarator" => Some(javascript::variable_declarator::reader),
        "while_statement" => Some(javascript::while_statement::reader),
        "yield_expression" => Some(javascript::yield_expression::reader),
        _ => None,
    }
}

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

    #[test]
    #[allow(clippy::too_many_lines, reason = "one assert per mapped node type")]
    fn maps_the_implemented_javascript_node_types() {
        assert!(dispatcher("program").is_some());
        assert!(dispatcher("comment").is_some());
        assert!(dispatcher("true").is_some());
        assert!(dispatcher("false").is_some());
        assert!(dispatcher("null").is_some());
        assert!(dispatcher("number").is_some());
        assert!(dispatcher("string").is_some());
        assert!(dispatcher("regex").is_some());
        assert!(dispatcher("undefined").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("ternary_expression").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("array").is_some());
        assert!(dispatcher("rest_pattern").is_some());
        assert!(dispatcher("identifier").is_some());
        assert!(dispatcher("property_identifier").is_some());
        assert!(dispatcher("shorthand_property_identifier").is_some());
        assert!(dispatcher("shorthand_property_identifier_pattern").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("template_string").is_some());
        assert!(dispatcher("catch_clause").is_some());
        assert!(dispatcher("finally_clause").is_some());
        assert!(dispatcher("import").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());
        assert!(dispatcher("debugger_statement").is_some());
        assert!(dispatcher("yield_expression").is_some());
        assert!(dispatcher("object").is_some());
        assert!(dispatcher("pair").is_some());
        assert!(dispatcher("pair_pattern").is_some());
        assert!(dispatcher("formal_parameters").is_some());
        assert!(dispatcher("arguments").is_some());
        assert!(dispatcher("statement_block").is_some());
        assert!(dispatcher("class_body").is_some());
        assert!(dispatcher("do_statement").is_some());
        assert!(dispatcher("try_statement").is_some());
        assert!(dispatcher("if_statement").is_some());
        assert!(dispatcher("else_clause").is_some());
        assert!(dispatcher("while_statement").is_some());
        assert!(dispatcher("for_statement").is_some());
        assert!(dispatcher("for_in_statement").is_some());
        assert!(dispatcher("switch_statement").is_some());
        assert!(dispatcher("switch_body").is_some());
        assert!(dispatcher("function").is_some());
        assert!(dispatcher("function_declaration").is_some());
        assert!(dispatcher("function_expression").is_some());
        assert!(dispatcher("generator_function_declaration").is_some());
        assert!(dispatcher("method_definition").is_some());
        assert!(dispatcher("arrow_function").is_some());
        assert!(dispatcher("switch_case").is_some());
        assert!(dispatcher("switch_default").is_some());
        assert!(dispatcher("field_definition").is_some());
        assert!(dispatcher("jsx_attribute").is_some());
        assert!(dispatcher("object_pattern").is_some());
        assert!(dispatcher("export_statement").is_some());
        assert!(dispatcher("call_expression").is_some());
        assert!(dispatcher("class_declaration").is_some());
        assert!(dispatcher("lexical_declaration").is_some());
        assert!(dispatcher("variable_declaration").is_some());
        assert!(dispatcher("variable_declarator").is_some());
    }

    #[test]
    fn unmapped_node_types_have_no_reader() {
        assert!(dispatcher("nested_identifier").is_none());
        assert!(dispatcher("jsx_fragment").is_none());
        assert!(dispatcher("").is_none());
    }
}