fluidattacks-blends-domain 0.41.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

use crate::syntax::readers::swift;
use crate::syntax::SyntaxReader;

#[allow(clippy::too_many_lines, reason = "flat node-type dispatch table")]
pub fn dispatcher(node_type: &str) -> Option<SyntaxReader> {
    match node_type {
        "source_file" => Some(swift::source_file::reader),
        "boolean_literal" => Some(swift::boolean_literal::reader),
        "integer_literal" => Some(swift::integer_literal::reader),
        "nil" => Some(swift::nil::reader),
        "constructor_expression"
        | "identifier"
        | "open_start_range_expression"
        | "self_expression"
        | "simple_identifier"
        | "switch_pattern" => Some(swift::identifier::reader),
        "comment" | "directive" | "multiline_comment" => Some(swift::comment::reader),
        "array_literal" => Some(swift::array_node::reader),
        "dictionary_literal" => Some(swift::dictionary_literal::reader),
        "super_expression" => Some(swift::reserved_word::reader),
        "enum_type_parameters"
        | "line_string_literal"
        | "multi_line_string_literal"
        | "tuple_expression"
        | "user_type" => Some(swift::string_literal::reader),
        "additive_expression"
        | "bitwise_operation"
        | "comparison_expression"
        | "conjunction_expression"
        | "disjunction_expression"
        | "equality_expression"
        | "infix_expression"
        | "multiplicative_expression" => Some(swift::binary_expression::reader),
        "as_expression" => Some(swift::as_expression::reader),
        "await_expression" => Some(swift::await_expression::reader),
        "try_expression" => Some(swift::try_expression::reader),
        "ternary_expression" => Some(swift::ternary_expression::reader),
        "nil_coalescing_expression" => Some(swift::if_nil_expression::reader),
        "prefix_expression" => Some(swift::prefix_expression::reader),
        "postfix_expression" => Some(swift::update_expression::reader),
        "navigation_expression" => Some(swift::navigation_expression::reader),
        "navigation_suffix" => Some(swift::navigation_suffix::reader),
        "availability_condition" => Some(swift::availability_condition::reader),
        "call_suffix" => Some(swift::call_suffix::reader),
        "call_expression" => Some(swift::call_expression::reader),
        "value_argument" => Some(swift::value_argument::reader),
        "value_arguments" => Some(swift::value_arguments::reader),
        "lambda_literal" => Some(swift::lambda_function::reader),
        "directly_assignable_expression" | "pattern" => Some(swift::expression_statement::reader),
        "assignment" => Some(swift::assignment::reader),
        "statements" => Some(swift::statements::reader),
        "control_transfer_statement" => Some(swift::control_transfer::reader),
        "switch_entry" => Some(swift::switch_entry::reader),
        "switch_statement" => Some(swift::switch_statement::reader),
        "if_statement" | "guard_statement" => Some(swift::if_statement::reader),
        "while_statement" | "repeat_while_statement" => Some(swift::while_statement::reader),
        "for_statement" => Some(swift::for_statement::reader),
        "do_statement" => Some(swift::do_statement::reader),
        "class_declaration" => Some(swift::class_declaration::reader),
        "class_body" | "enum_class_body" | "protocol_body" => Some(swift::class_body::reader),
        "protocol_declaration" => Some(swift::protocol_declaration::reader),
        "import_declaration" => Some(swift::import_statement::reader),
        "enum_entry" => Some(swift::enum_entry::reader),
        "function_body" | "computed_property" => Some(swift::function_body::reader),
        "function_declaration" | "init_declaration" | "protocol_function_declaration" => {
            Some(swift::function_declaration::reader)
        }
        "parameter" => Some(swift::parameter::reader),
        "property_declaration" | "protocol_property_declaration" | "typealias_declaration" => {
            Some(swift::property_declaration::reader)
        }
        _ => None,
    }
}

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

    #[test]
    #[allow(clippy::too_many_lines, reason = "flat node-type dispatch table")]
    fn maps_the_implemented_swift_node_types() {
        assert!(dispatcher("source_file").is_some());
        assert!(dispatcher("boolean_literal").is_some());
        assert!(dispatcher("integer_literal").is_some());
        assert!(dispatcher("nil").is_some());
        assert!(dispatcher("constructor_expression").is_some());
        assert!(dispatcher("identifier").is_some());
        assert!(dispatcher("open_start_range_expression").is_some());
        assert!(dispatcher("self_expression").is_some());
        assert!(dispatcher("simple_identifier").is_some());
        assert!(dispatcher("switch_pattern").is_some());
        assert!(dispatcher("comment").is_some());
        assert!(dispatcher("directive").is_some());
        assert!(dispatcher("multiline_comment").is_some());
        assert!(dispatcher("array_literal").is_some());
        assert!(dispatcher("dictionary_literal").is_some());
        assert!(dispatcher("super_expression").is_some());
        assert!(dispatcher("enum_type_parameters").is_some());
        assert!(dispatcher("line_string_literal").is_some());
        assert!(dispatcher("multi_line_string_literal").is_some());
        assert!(dispatcher("tuple_expression").is_some());
        assert!(dispatcher("user_type").is_some());
        assert!(dispatcher("additive_expression").is_some());
        assert!(dispatcher("bitwise_operation").is_some());
        assert!(dispatcher("comparison_expression").is_some());
        assert!(dispatcher("conjunction_expression").is_some());
        assert!(dispatcher("disjunction_expression").is_some());
        assert!(dispatcher("equality_expression").is_some());
        assert!(dispatcher("infix_expression").is_some());
        assert!(dispatcher("multiplicative_expression").is_some());
        assert!(dispatcher("as_expression").is_some());
        assert!(dispatcher("await_expression").is_some());
        assert!(dispatcher("try_expression").is_some());
        assert!(dispatcher("ternary_expression").is_some());
        assert!(dispatcher("nil_coalescing_expression").is_some());
        assert!(dispatcher("prefix_expression").is_some());
        assert!(dispatcher("postfix_expression").is_some());
        assert!(dispatcher("navigation_expression").is_some());
        assert!(dispatcher("navigation_suffix").is_some());
        assert!(dispatcher("availability_condition").is_some());
        assert!(dispatcher("call_suffix").is_some());
        assert!(dispatcher("call_expression").is_some());
        assert!(dispatcher("value_argument").is_some());
        assert!(dispatcher("value_arguments").is_some());
        assert!(dispatcher("lambda_literal").is_some());
        assert!(dispatcher("directly_assignable_expression").is_some());
        assert!(dispatcher("pattern").is_some());
        assert!(dispatcher("assignment").is_some());
        assert!(dispatcher("statements").is_some());
        assert!(dispatcher("control_transfer_statement").is_some());
        assert!(dispatcher("switch_entry").is_some());
        assert!(dispatcher("switch_statement").is_some());
        assert!(dispatcher("if_statement").is_some());
        assert!(dispatcher("guard_statement").is_some());
        assert!(dispatcher("while_statement").is_some());
        assert!(dispatcher("repeat_while_statement").is_some());
        assert!(dispatcher("for_statement").is_some());
        assert!(dispatcher("do_statement").is_some());
        assert!(dispatcher("class_declaration").is_some());
        assert!(dispatcher("class_body").is_some());
        assert!(dispatcher("enum_class_body").is_some());
        assert!(dispatcher("protocol_body").is_some());
        assert!(dispatcher("protocol_declaration").is_some());
        assert!(dispatcher("import_declaration").is_some());
        assert!(dispatcher("enum_entry").is_some());
        assert!(dispatcher("function_body").is_some());
        assert!(dispatcher("computed_property").is_some());
        assert!(dispatcher("function_declaration").is_some());
        assert!(dispatcher("init_declaration").is_some());
        assert!(dispatcher("protocol_function_declaration").is_some());
        assert!(dispatcher("parameter").is_some());
        assert!(dispatcher("property_declaration").is_some());
        assert!(dispatcher("protocol_property_declaration").is_some());
        assert!(dispatcher("typealias_declaration").is_some());
    }
}