use super::LocName;
use crate::{Node, Loc};
crate::use_native_or_external!(Maybe);
impl LocName {
fn get_begin_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_args() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_array() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_array_pattern() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_array_pattern_with_tail() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_begin() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_block() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_const_pattern() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_c_send() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_defined() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_dstr() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_dsym() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_find_pattern() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_for() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_hash() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_hash_pattern() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_if() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_index() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_index_asgn() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_in_pattern() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_kw_begin() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_mlhs() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_numblock() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_postexe() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_preexe() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_procarg0() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_regexp() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_rescue_body() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_send() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_str() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_super() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_sym() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_until() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_when() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_while() {
return inner.get_begin_l().clone()
} else if let Some(inner) = node.as_xstr() {
return Maybe::some(inner.get_begin_l().clone())
} else if let Some(inner) = node.as_yield() {
return inner.get_begin_l().clone()
}
else {
panic!("node {} doesn't support begin_l loc", node.str_type())
}
}
fn get_end_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_args() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_array() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_array_pattern() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_array_pattern_with_tail() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_begin() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_block() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_case() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_case_match() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_class() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_const_pattern() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_c_send() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_def() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_defined() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_defs() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_dstr() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_dsym() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_find_pattern() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_for() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_hash() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_hash_pattern() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_if() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_index() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_index_asgn() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_kw_begin() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_mlhs() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_module() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_numblock() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_postexe() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_preexe() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_procarg0() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_regexp() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_s_class() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_send() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_str() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_super() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_sym() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_until() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_while() {
return inner.get_end_l().clone()
} else if let Some(inner) = node.as_xstr() {
return Maybe::some(inner.get_end_l().clone())
} else if let Some(inner) = node.as_yield() {
return inner.get_end_l().clone()
}
else {
panic!("node {} doesn't support end_l loc", node.str_type())
}
}
fn get_expression_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_alias() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_and() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_and_asgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_arg() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_args() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_array() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_array_pattern() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_array_pattern_with_tail() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_back_ref() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_begin() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_block() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_blockarg() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_block_pass() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_break() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_case() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_case_match() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_casgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_cbase() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_class() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_complex() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_const() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_const_pattern() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_c_send() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_cvar() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_cvasgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_def() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_defined() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_defs() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_dstr() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_dsym() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_e_flip_flop() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_empty_else() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_encoding() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_ensure() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_erange() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_false() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_file() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_find_pattern() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_float() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_for() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_forward_arg() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_forwarded_args() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_gvar() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_gvasgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_hash() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_hash_pattern() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_heredoc() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_if() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_if_guard() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_i_flip_flop() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_if_mod() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_if_ternary() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_index() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_index_asgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_in_pattern() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_int() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_irange() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_ivar() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_ivasgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_kwarg() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_kwargs() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_kw_begin() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_kwnilarg() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_kwoptarg() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_kwrestarg() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_kwsplat() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_lambda() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_line() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_lvar() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_lvasgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_masgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_match_alt() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_match_as() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_match_current_line() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_match_nil_pattern() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_match_pattern() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_match_pattern_p() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_match_rest() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_match_var() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_match_with_lvasgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_mlhs() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_module() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_next() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_nil() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_nth_ref() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_numblock() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_op_asgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_optarg() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_or() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_or_asgn() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_pair() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_pin() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_postexe() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_preexe() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_procarg0() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_rational() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_redo() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_regexp() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_reg_opt() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_rescue() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_rescue_body() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_restarg() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_retry() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_return() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_s_class() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_self_() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_send() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_shadowarg() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_splat() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_str() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_super() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_sym() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_true() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_undef() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_unless_guard() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_until() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_until_post() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_when() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_while() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_while_post() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_x_heredoc() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_xstr() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_yield() {
return Maybe::some(inner.get_expression_l().clone())
} else if let Some(inner) = node.as_z_super() {
return Maybe::some(inner.get_expression_l().clone())
}
else {
panic!("node {} doesn't support expression_l loc", node.str_type())
}
}
fn get_keyword_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_alias() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_break() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_case() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_case_match() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_class() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_def() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_defined() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_defs() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_ensure() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_for() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_if() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_if_guard() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_if_mod() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_in_pattern() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_module() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_next() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_postexe() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_preexe() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_rescue_body() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_return() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_s_class() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_super() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_undef() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_unless_guard() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_until() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_until_post() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_when() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_while() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_while_post() {
return Maybe::some(inner.get_keyword_l().clone())
} else if let Some(inner) = node.as_yield() {
return Maybe::some(inner.get_keyword_l().clone())
}
else {
panic!("node {} doesn't support keyword_l loc", node.str_type())
}
}
fn get_name_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_blockarg() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_casgn() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_const() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_cvasgn() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_def() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_defs() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_gvasgn() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_ivasgn() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_kwarg() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_kwnilarg() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_kwoptarg() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_kwrestarg() {
return inner.get_name_l().clone()
} else if let Some(inner) = node.as_lvasgn() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_match_nil_pattern() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_match_var() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_optarg() {
return Maybe::some(inner.get_name_l().clone())
} else if let Some(inner) = node.as_restarg() {
return inner.get_name_l().clone()
}
else {
panic!("node {} doesn't support name_l loc", node.str_type())
}
}
fn get_assignment_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_def() {
return inner.get_assignment_l().clone()
} else if let Some(inner) = node.as_defs() {
return inner.get_assignment_l().clone()
}
else {
panic!("node {} doesn't support assignment_l loc", node.str_type())
}
}
fn get_colon_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_if_ternary() {
return Maybe::some(inner.get_colon_l().clone())
}
else {
panic!("node {} doesn't support colon_l loc", node.str_type())
}
}
fn get_double_colon_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_casgn() {
return inner.get_double_colon_l().clone()
} else if let Some(inner) = node.as_const() {
return inner.get_double_colon_l().clone()
}
else {
panic!("node {} doesn't support double_colon_l loc", node.str_type())
}
}
fn get_else_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_case() {
return inner.get_else_l().clone()
} else if let Some(inner) = node.as_case_match() {
return inner.get_else_l().clone()
} else if let Some(inner) = node.as_if() {
return inner.get_else_l().clone()
} else if let Some(inner) = node.as_rescue() {
return inner.get_else_l().clone()
}
else {
panic!("node {} doesn't support else_l loc", node.str_type())
}
}
fn get_heredoc_body_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_heredoc() {
return Maybe::some(inner.get_heredoc_body_l().clone())
} else if let Some(inner) = node.as_x_heredoc() {
return Maybe::some(inner.get_heredoc_body_l().clone())
}
else {
panic!("node {} doesn't support heredoc_body_l loc", node.str_type())
}
}
fn get_operator_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_and() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_and_asgn() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_blockarg() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_block_pass() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_casgn() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_class() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_complex() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_c_send() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_cvasgn() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_defs() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_e_flip_flop() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_erange() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_float() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_for() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_gvasgn() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_i_flip_flop() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_index_asgn() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_int() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_irange() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_ivasgn() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_kwrestarg() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_kwsplat() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_lvasgn() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_masgn() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_match_alt() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_match_as() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_match_nil_pattern() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_match_pattern() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_match_pattern_p() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_match_rest() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_match_with_lvasgn() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_op_asgn() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_optarg() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_or() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_or_asgn() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_pair() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_rational() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_restarg() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_s_class() {
return Maybe::some(inner.get_operator_l().clone())
} else if let Some(inner) = node.as_send() {
return inner.get_operator_l().clone()
} else if let Some(inner) = node.as_splat() {
return Maybe::some(inner.get_operator_l().clone())
}
else {
panic!("node {} doesn't support operator_l loc", node.str_type())
}
}
fn get_selector_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_c_send() {
return inner.get_selector_l().clone()
} else if let Some(inner) = node.as_pin() {
return Maybe::some(inner.get_selector_l().clone())
} else if let Some(inner) = node.as_send() {
return inner.get_selector_l().clone()
}
else {
panic!("node {} doesn't support selector_l loc", node.str_type())
}
}
fn get_assoc_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_rescue_body() {
return inner.get_assoc_l().clone()
}
else {
panic!("node {} doesn't support assoc_l loc", node.str_type())
}
}
fn get_question_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_if_ternary() {
return Maybe::some(inner.get_question_l().clone())
}
else {
panic!("node {} doesn't support question_l loc", node.str_type())
}
}
fn get_heredoc_end_l(node: &Node) -> Maybe<Loc> {
if let Some(inner) = node.as_heredoc() {
return Maybe::some(inner.get_heredoc_end_l().clone())
} else if let Some(inner) = node.as_x_heredoc() {
return Maybe::some(inner.get_heredoc_end_l().clone())
}
else {
panic!("node {} doesn't support heredoc_end_l loc", node.str_type())
}
}
pub(crate) fn get(&self, node: &Node) -> Maybe<Loc> {
match self {
LocName::Begin => Self::get_begin_l(node),
LocName::End => Self::get_end_l(node),
LocName::Expression => Self::get_expression_l(node),
LocName::Keyword => Self::get_keyword_l(node),
LocName::Name => Self::get_name_l(node),
LocName::Assignment => Self::get_assignment_l(node),
LocName::Colon => Self::get_colon_l(node),
LocName::DoubleColon => Self::get_double_colon_l(node),
LocName::Else => Self::get_else_l(node),
LocName::HeredocBody => Self::get_heredoc_body_l(node),
LocName::Operator => Self::get_operator_l(node),
LocName::Selector => Self::get_selector_l(node),
LocName::Assoc => Self::get_assoc_l(node),
LocName::Question => Self::get_question_l(node),
LocName::HeredocEnd => Self::get_heredoc_end_l(node),
}
}
}