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

use crate::syntax::readers::kotlin;
use crate::syntax::SyntaxReader;

#[must_use]
pub fn dispatcher(node_type: &str) -> Option<SyntaxReader> {
    match node_type {
        "source_file" => Some(kotlin::source_file::reader),
        "number_literal" => Some(kotlin::number_literal::reader),
        "string_literal" | "multiline_string_literal" => Some(kotlin::string_literal::reader),
        "string_content" => Some(kotlin::string_content::reader),
        "block_comment" | "line_comment" => Some(kotlin::comment::reader),
        "super_expression" | "this_expression" => Some(kotlin::reserved_word::reader),
        "identifier" => Some(kotlin::identifier::reader),
        "binary_expression" => Some(kotlin::binary_expression::reader),
        "in_expression" => Some(kotlin::in_expression::reader),
        "infix_expression" => Some(kotlin::infix_expression::reader),
        "unary_expression" => Some(kotlin::unary_expression::reader),
        "index_expression" => Some(kotlin::index_expression::reader),
        "navigation_expression" => Some(kotlin::member_access_expression::reader),
        "parenthesized_expression" => Some(kotlin::parenthesized_expression::reader),
        "value_arguments" => Some(kotlin::argument_list::reader),
        "expression" => Some(kotlin::expression_statement::reader),
        "call_expression" => Some(kotlin::method_invocation::reader),
        "assignment" | "range_expression" => Some(kotlin::assignment_expression::reader),
        "if_expression" => Some(kotlin::if_statement::reader),
        "while_statement" => Some(kotlin::while_statement::reader),
        "for_statement" => Some(kotlin::for_statement::reader),
        "when_expression" => Some(kotlin::when_expression::reader),
        "statement" => Some(kotlin::statements::reader),
        "when_entry" => Some(kotlin::when_entry::reader),
        "return_expression" | "throw_expression" => Some(kotlin::jump_statement::reader),
        "try_expression" => Some(kotlin::try_statement::reader),
        "catch_block" => Some(kotlin::catch_clause::reader),
        "finally_block" => Some(kotlin::finally_clause::reader),
        "block" | "function_body" | "lambda_literal" => Some(kotlin::statement_block::reader),
        "import" | "package_header" => Some(kotlin::import_declaration::reader),
        "annotation" => Some(kotlin::annotation::reader),
        "modifiers" => Some(kotlin::modifiers::reader),
        "parameter" => Some(kotlin::parameter::reader),
        "function_value_parameters" => Some(kotlin::parameter_list::reader),
        "class_declaration" | "object_declaration" => Some(kotlin::class_declaration::reader),
        "class_body" => Some(kotlin::class_body::reader),
        "object_literal" => Some(kotlin::object::reader),
        "companion_object" => Some(kotlin::companion_object::reader),
        "property_declaration" => Some(kotlin::variable_declaration::reader),
        "function_declaration" | "anonymous_initializer" => {
            Some(kotlin::method_declaration::reader)
        }
        "value_argument" => Some(kotlin::value_argument::reader),
        _ => None,
    }
}
#[cfg(test)]
mod tests {
    use super::dispatcher;

    #[test]
    #[allow(
        clippy::too_many_lines,
        reason = "one assertion per wired node type keeps the coverage explicit"
    )]
    fn maps_the_implemented_kotlin_node_types() {
        assert!(dispatcher("source_file").is_some());
        assert!(dispatcher("number_literal").is_some());
        assert!(dispatcher("string_literal").is_some());
        assert!(dispatcher("multiline_string_literal").is_some());
        assert!(dispatcher("string_content").is_some());
        assert!(dispatcher("block_comment").is_some());
        assert!(dispatcher("line_comment").is_some());
        assert!(dispatcher("super_expression").is_some());
        assert!(dispatcher("this_expression").is_some());
        assert!(dispatcher("identifier").is_some());
        assert!(dispatcher("binary_expression").is_some());
        assert!(dispatcher("in_expression").is_some());
        assert!(dispatcher("infix_expression").is_some());
        assert!(dispatcher("unary_expression").is_some());
        assert!(dispatcher("index_expression").is_some());
        assert!(dispatcher("navigation_expression").is_some());
        assert!(dispatcher("parenthesized_expression").is_some());
        assert!(dispatcher("value_arguments").is_some());
        assert!(dispatcher("expression").is_some());
        assert!(dispatcher("call_expression").is_some());
        assert!(dispatcher("assignment").is_some());
        assert!(dispatcher("range_expression").is_some());
        assert!(dispatcher("if_expression").is_some());
        assert!(dispatcher("while_statement").is_some());
        assert!(dispatcher("for_statement").is_some());
        assert!(dispatcher("when_expression").is_some());
        assert!(dispatcher("statement").is_some());
        assert!(dispatcher("when_entry").is_some());
        assert!(dispatcher("return_expression").is_some());
        assert!(dispatcher("throw_expression").is_some());
        assert!(dispatcher("try_expression").is_some());
        assert!(dispatcher("catch_block").is_some());
        assert!(dispatcher("finally_block").is_some());
        assert!(dispatcher("block").is_some());
        assert!(dispatcher("function_body").is_some());
        assert!(dispatcher("lambda_literal").is_some());
        assert!(dispatcher("import").is_some());
        assert!(dispatcher("package_header").is_some());
        assert!(dispatcher("annotation").is_some());
        assert!(dispatcher("modifiers").is_some());
        assert!(dispatcher("parameter").is_some());
        assert!(dispatcher("value_argument").is_some());
        assert!(dispatcher("function_value_parameters").is_some());
        assert!(dispatcher("class_declaration").is_some());
        assert!(dispatcher("object_declaration").is_some());
        assert!(dispatcher("class_body").is_some());
        assert!(dispatcher("object_literal").is_some());
        assert!(dispatcher("companion_object").is_some());
        assert!(dispatcher("property_declaration").is_some());
        assert!(dispatcher("function_declaration").is_some());
        assert!(dispatcher("anonymous_initializer").is_some());
    }
}