use crate::syntax::readers::python;
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 {
"argument_list" => Some(python::argument_list::reader),
"as_pattern" => Some(python::as_pattern::reader),
"assert_statement" => Some(python::assert_statement::reader),
"assignment" => Some(python::assignment::reader),
"attribute" => Some(python::attribute::reader),
"augmented_assignment" | "binary_operator" | "boolean_operator" | "comparison_operator" => {
Some(python::binary_expression::reader)
}
"await" => Some(python::await_expression::reader),
"block" => Some(python::execution_block::reader),
"break_statement" => Some(python::break_statement::reader),
"call" => Some(python::call::reader),
"class_definition" => Some(python::class_definition::reader),
"comment" => Some(python::comment::reader),
"conditional_expression" => Some(python::conditional_expression::reader),
"decorated_definition" => Some(python::decorated_definition::reader),
"dictionary_comprehension" | "list_comprehension" | "set_comprehension" => {
Some(python::comprehension::reader)
}
"generator_expression" => Some(python::generator_expression::reader),
"if_clause" => Some(python::if_clause::reader),
"keyword_argument" => Some(python::argument::reader),
"continue_statement" | "pass_statement" => Some(python::continue_statement::reader),
"decorator" => Some(python::decorator::reader),
"dictionary" => Some(python::dictionary::reader),
"dictionary_splat" => Some(python::dictionary_splat::reader),
"dictionary_splat_pattern" | "list_splat_pattern" => Some(python::splat_pattern::reader),
"elif_clause" | "if_statement" => Some(python::if_statement::reader),
"else_clause" => Some(python::else_clause::reader),
"except_clause" => Some(python::except_clause::reader),
"finally_clause" => Some(python::finally_clause::reader),
"dotted_name" => Some(python::import_global::reader),
"for_in_clause" => Some(python::for_in_clause::reader),
"for_statement" => Some(python::for_statement::reader),
"default_parameter" | "parameter" | "typed_default_parameter" | "typed_parameter" => {
Some(python::parameter::reader)
}
"delete_statement" | "expression_statement" | "global_statement" => {
Some(python::expression_statement::reader)
}
"expression_list" | "list_splat" | "slice" | "string" => {
Some(python::string_literal::reader)
}
"false" | "true" => Some(python::boolean_literal::reader),
"float" | "integer" => Some(python::number_literal::reader),
"function_definition" => Some(python::function_definition::reader),
"identifier" => Some(python::identifier::reader),
"in" | "none" | "pass" | "return" => Some(python::reserved_word::reader),
"list" | "pattern_list" | "set" | "tuple" | "tuple_pattern" => {
Some(python::array_node::reader)
}
"module" => Some(python::module::reader),
"named_expression" => Some(python::named_expression::reader),
"not_operator" => Some(python::not_operator::reader),
"pair" => Some(python::pair::reader),
"parameters" => Some(python::parameters::reader),
"parenthesized_expression" => Some(python::parenthesized_expression::reader),
"raise_statement" => Some(python::raise_statement::reader),
"return_statement" | "yield" => Some(python::return_statement::reader),
"subscript" => Some(python::subscript::reader),
"try_statement" => Some(python::try_statement::reader),
"unary_operator" => Some(python::unary_expression::reader),
"while_statement" => Some(python::while_statement::reader),
"with_statement" => Some(python::using_statement::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_python_node_types() {
assert!(dispatcher("module").is_some());
assert!(dispatcher("comment").is_some());
assert!(dispatcher("identifier").is_some());
assert!(dispatcher("true").is_some());
assert!(dispatcher("false").is_some());
assert!(dispatcher("integer").is_some());
assert!(dispatcher("float").is_some());
assert!(dispatcher("string").is_some());
assert!(dispatcher("expression_list").is_some());
assert!(dispatcher("list_splat").is_some());
assert!(dispatcher("slice").is_some());
assert!(dispatcher("block").is_some());
assert!(dispatcher("expression_statement").is_some());
assert!(dispatcher("delete_statement").is_some());
assert!(dispatcher("global_statement").is_some());
assert!(dispatcher("function_definition").is_some());
assert!(dispatcher("class_definition").is_some());
assert!(dispatcher("parameters").is_some());
assert!(dispatcher("parameter").is_some());
assert!(dispatcher("typed_parameter").is_some());
assert!(dispatcher("default_parameter").is_some());
assert!(dispatcher("typed_default_parameter").is_some());
assert!(dispatcher("attribute").is_some());
assert!(dispatcher("call").is_some());
assert!(dispatcher("argument_list").is_some());
assert!(dispatcher("return_statement").is_some());
assert!(dispatcher("yield").is_some());
assert!(dispatcher("parenthesized_expression").is_some());
assert!(dispatcher("subscript").is_some());
assert!(dispatcher("not_operator").is_some());
assert!(dispatcher("await").is_some());
assert!(dispatcher("break_statement").is_some());
assert!(dispatcher("continue_statement").is_some());
assert!(dispatcher("pass_statement").is_some());
assert!(dispatcher("conditional_expression").is_some());
assert!(dispatcher("named_expression").is_some());
assert!(dispatcher("pair").is_some());
assert!(dispatcher("unary_operator").is_some());
assert!(dispatcher("in").is_some());
assert!(dispatcher("none").is_some());
assert!(dispatcher("pass").is_some());
assert!(dispatcher("return").is_some());
assert!(dispatcher("binary_operator").is_some());
assert!(dispatcher("comparison_operator").is_some());
assert!(dispatcher("list").is_some());
assert!(dispatcher("tuple").is_some());
assert!(dispatcher("set").is_some());
assert!(dispatcher("dictionary").is_some());
assert!(dispatcher("decorator").is_some());
assert!(dispatcher("else_clause").is_some());
assert!(dispatcher("raise_statement").is_some());
assert!(dispatcher("while_statement").is_some());
assert!(dispatcher("as_pattern").is_some());
assert!(dispatcher("assert_statement").is_some());
assert!(dispatcher("dictionary_splat").is_some());
assert!(dispatcher("list_splat_pattern").is_some());
assert!(dispatcher("dictionary_splat_pattern").is_some());
assert!(dispatcher("if_statement").is_some());
assert!(dispatcher("elif_clause").is_some());
assert!(dispatcher("for_statement").is_some());
assert!(dispatcher("for_in_clause").is_some());
assert!(dispatcher("try_statement").is_some());
assert!(dispatcher("except_clause").is_some());
assert!(dispatcher("finally_clause").is_some());
assert!(dispatcher("with_statement").is_some());
assert!(dispatcher("keyword_argument").is_some());
assert!(dispatcher("generator_expression").is_some());
assert!(dispatcher("if_clause").is_some());
assert!(dispatcher("list_comprehension").is_some());
assert!(dispatcher("set_comprehension").is_some());
assert!(dispatcher("dictionary_comprehension").is_some());
assert!(dispatcher("dotted_name").is_some());
assert!(dispatcher("assignment").is_some());
assert!(dispatcher("decorated_definition").is_some());
}
#[test]
fn unmapped_node_types_have_no_reader() {
assert!(dispatcher("lambda").is_none());
assert!(dispatcher("").is_none());
}
}