fluidattacks-blends-domain 0.3.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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

use crate::syntax::readers::java;
use crate::syntax::SyntaxReader;

#[must_use]
#[allow(
    clippy::too_many_lines,
    reason = "exhaustive 1:1 dispatch table: one arm per node label, nothing to extract"
)]
pub fn dispatcher(node_type: &str) -> Option<SyntaxReader> {
    match node_type {
        "block_comment" | "line_comment" => Some(java::comment::reader),
        "character_literal" | "string_literal" => Some(java::string_literal::reader),
        "class_literal"
        | "field_access"
        | "identifier"
        | "scoped_type_identifier"
        | "type_identifier" => Some(java::identifier::reader),
        "binary_integer_literal"
        | "decimal_floating_point_literal"
        | "decimal_integer_literal"
        | "hex_floating_point_literal"
        | "hex_integer_literal"
        | "octal_integer_literal" => Some(java::number_literal::reader),
        "false" | "true" => Some(java::boolean_literal::reader),
        "modifiers" => Some(java::modifiers::reader),
        "null_literal" => Some(java::null_literal::reader),
        "program" => Some(java::program::reader),
        "catch_clause" => Some(java::catch_clause::reader),
        "catch_formal_parameter" => Some(java::catch_parameter::reader),
        "finally_clause" => Some(java::finally_clause::reader),
        "resource" => Some(java::resource_node::reader),
        "return_statement" => Some(java::return_statement::reader),
        "switch_block" => Some(java::switch_body::reader),
        "switch_block_statement_group" => Some(java::switch_section::reader),
        "switch_expression" => Some(java::switch_statement::reader),
        "throw_statement" => Some(java::throw_statement::reader),
        "try_statement" | "try_with_resources_statement" => Some(java::try_statement::reader),
        "argument_list" => Some(java::argument_list::reader),
        "array_access" => Some(java::array_access::reader),
        "array_creation_expression" => Some(java::array_creation_expression::reader),
        "array_initializer" | "element_value_array_initializer" => Some(java::array_node::reader),
        "assignment_expression" => Some(java::assignment_expression::reader),
        "binary_expression" => Some(java::binary_expression::reader),
        "cast_expression" => Some(java::cast_expression::reader),
        "instanceof_expression" => Some(java::instanceof_expression::reader),
        "method_invocation" => Some(java::method_invocation::reader),
        "object_creation_expression" => Some(java::object_creation_expression::reader),
        "parenthesized_expression" => Some(java::parenthesized_expression::reader),
        "ternary_expression" => Some(java::ternary_expression::reader),
        "this" => Some(java::this_node::reader),
        "unary_expression" => Some(java::unary_expression::reader),
        "update_expression" => Some(java::update_expression::reader),
        "block" | "resource_specification" => Some(java::execution_block::reader),
        "break_statement" => Some(java::break_statement::reader),
        "continue_statement" => Some(java::continue_statement::reader),
        "do_statement" => Some(java::do_statement::reader),
        "enhanced_for_statement" => Some(java::enhanced_for_statement::reader),
        "expression_statement" => Some(java::expression_statement::reader),
        "for_statement" => Some(java::for_statement::reader),
        "if_statement" => Some(java::if_statement::reader),
        "while_statement" => Some(java::while_statement::reader),
        "annotation_argument_list" => Some(java::annotation_argument_list::reader),
        "element_value_pair" => Some(java::element_value_pair::reader),
        "package_declaration" => Some(java::package_declaration::reader),
        "annotation" | "marker_annotation" => Some(java::annotation::reader),
        "constant_declaration" | "local_variable_declaration" => {
            Some(java::variable_declaration::reader)
        }
        "field_declaration" => Some(java::field_declaration::reader),
        "formal_parameter" => Some(java::parameter::reader),
        "formal_parameters" | "inferred_parameters" | "record_pattern_body" => {
            Some(java::parameter_list::reader)
        }
        "import_declaration" => Some(java::import_declaration::reader),
        "lambda_expression" => Some(java::lambda_expression::reader),
        "variable_declarator" => Some(java::variable_declarator::reader),
        "class_body" | "constructor_body" | "interface_body" => Some(java::class_body::reader),
        "class_declaration" | "record_declaration" => Some(java::class_declaration::reader),
        "record_pattern" => Some(java::record_pattern::reader),
        "record_pattern_component" => Some(java::record_pattern_component::reader),
        "constructor_declaration" | "method_declaration" => Some(java::method_declaration::reader),
        "interface_declaration" => Some(java::interface_declaration::reader),
        _ => None,
    }
}

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

    #[test]
    #[allow(
        clippy::too_many_lines,
        reason = "one assertion per mapped node label, nothing to extract"
    )]
    fn maps_the_implemented_java_node_types() {
        assert!(dispatcher("program").is_some());
        assert!(dispatcher("line_comment").is_some());
        assert!(dispatcher("block_comment").is_some());
        assert!(dispatcher("true").is_some());
        assert!(dispatcher("false").is_some());
        assert!(dispatcher("null_literal").is_some());
        assert!(dispatcher("binary_integer_literal").is_some());
        assert!(dispatcher("decimal_floating_point_literal").is_some());
        assert!(dispatcher("decimal_integer_literal").is_some());
        assert!(dispatcher("hex_floating_point_literal").is_some());
        assert!(dispatcher("hex_integer_literal").is_some());
        assert!(dispatcher("octal_integer_literal").is_some());
        assert!(dispatcher("character_literal").is_some());
        assert!(dispatcher("string_literal").is_some());
        assert!(dispatcher("identifier").is_some());
        assert!(dispatcher("field_access").is_some());
        assert!(dispatcher("scoped_type_identifier").is_some());
        assert!(dispatcher("type_identifier").is_some());
        assert!(dispatcher("class_literal").is_some());
        assert!(dispatcher("modifiers").is_some());
        assert!(dispatcher("class_body").is_some());
        assert!(dispatcher("constructor_body").is_some());
        assert!(dispatcher("interface_body").is_some());
        assert!(dispatcher("class_declaration").is_some());
        assert!(dispatcher("record_declaration").is_some());
        assert!(dispatcher("record_pattern").is_some());
        assert!(dispatcher("record_pattern_body").is_some());
        assert!(dispatcher("record_pattern_component").is_some());
        assert!(dispatcher("constructor_declaration").is_some());
        assert!(dispatcher("method_declaration").is_some());
        assert!(dispatcher("interface_declaration").is_some());
        assert!(dispatcher("annotation").is_some());
        assert!(dispatcher("marker_annotation").is_some());
        assert!(dispatcher("local_variable_declaration").is_some());
        assert!(dispatcher("field_declaration").is_some());
        assert!(dispatcher("formal_parameter").is_some());
        assert!(dispatcher("formal_parameters").is_some());
        assert!(dispatcher("inferred_parameters").is_some());
        assert!(dispatcher("import_declaration").is_some());
        assert!(dispatcher("lambda_expression").is_some());
        assert!(dispatcher("variable_declarator").is_some());
        assert!(dispatcher("block").is_some());
        assert!(dispatcher("resource_specification").is_some());
        assert!(dispatcher("break_statement").is_some());
        assert!(dispatcher("continue_statement").is_some());
        assert!(dispatcher("do_statement").is_some());
        assert!(dispatcher("enhanced_for_statement").is_some());
        assert!(dispatcher("expression_statement").is_some());
        assert!(dispatcher("for_statement").is_some());
        assert!(dispatcher("if_statement").is_some());
        assert!(dispatcher("while_statement").is_some());
        assert!(dispatcher("annotation_argument_list").is_some());
        assert!(dispatcher("constant_declaration").is_some());
        assert!(dispatcher("element_value_pair").is_some());
        assert!(dispatcher("package_declaration").is_some());
        assert!(dispatcher("catch_clause").is_some());
        assert!(dispatcher("catch_formal_parameter").is_some());
        assert!(dispatcher("finally_clause").is_some());
        assert!(dispatcher("resource").is_some());
        assert!(dispatcher("return_statement").is_some());
        assert!(dispatcher("switch_block").is_some());
        assert!(dispatcher("switch_block_statement_group").is_some());
        assert!(dispatcher("switch_expression").is_some());
        assert!(dispatcher("throw_statement").is_some());
        assert!(dispatcher("try_statement").is_some());
        assert!(dispatcher("try_with_resources_statement").is_some());
        assert!(dispatcher("argument_list").is_some());
        assert!(dispatcher("array_access").is_some());
        assert!(dispatcher("array_creation_expression").is_some());
        assert!(dispatcher("array_initializer").is_some());
        assert!(dispatcher("element_value_array_initializer").is_some());
        assert!(dispatcher("assignment_expression").is_some());
        assert!(dispatcher("binary_expression").is_some());
        assert!(dispatcher("cast_expression").is_some());
        assert!(dispatcher("instanceof_expression").is_some());
        assert!(dispatcher("method_invocation").is_some());
        assert!(dispatcher("object_creation_expression").is_some());
        assert!(dispatcher("parenthesized_expression").is_some());
        assert!(dispatcher("ternary_expression").is_some());
        assert!(dispatcher("this").is_some());
        assert!(dispatcher("unary_expression").is_some());
        assert!(dispatcher("update_expression").is_some());
        assert!(dispatcher("assert_statement").is_none());
    }
}