use crate::nodes::InnerNode;
use crate::nodes::*;
use crate::Loc;
use crate::Bytes;
crate::use_native_or_external!(Ptr);
crate::use_native_or_external!(List);
crate::use_native_or_external!(Maybe);
crate::use_native_or_external!(StringPtr);
use crate::blobs::{HasBlob, Blob};
#[repr(C)]
pub struct Node {
pub(crate) blob: Blob<Self>,
}
impl std::fmt::Debug for Node {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(inner) = self.as_alias() {
return write!(f, "Alias({:?})", inner)
}
if let Some(inner) = self.as_and() {
return write!(f, "And({:?})", inner)
}
if let Some(inner) = self.as_and_asgn() {
return write!(f, "AndAsgn({:?})", inner)
}
if let Some(inner) = self.as_arg() {
return write!(f, "Arg({:?})", inner)
}
if let Some(inner) = self.as_args() {
return write!(f, "Args({:?})", inner)
}
if let Some(inner) = self.as_array() {
return write!(f, "Array({:?})", inner)
}
if let Some(inner) = self.as_array_pattern() {
return write!(f, "ArrayPattern({:?})", inner)
}
if let Some(inner) = self.as_array_pattern_with_tail() {
return write!(f, "ArrayPatternWithTail({:?})", inner)
}
if let Some(inner) = self.as_back_ref() {
return write!(f, "BackRef({:?})", inner)
}
if let Some(inner) = self.as_begin() {
return write!(f, "Begin({:?})", inner)
}
if let Some(inner) = self.as_block() {
return write!(f, "Block({:?})", inner)
}
if let Some(inner) = self.as_blockarg() {
return write!(f, "Blockarg({:?})", inner)
}
if let Some(inner) = self.as_block_pass() {
return write!(f, "BlockPass({:?})", inner)
}
if let Some(inner) = self.as_break() {
return write!(f, "Break({:?})", inner)
}
if let Some(inner) = self.as_case() {
return write!(f, "Case({:?})", inner)
}
if let Some(inner) = self.as_case_match() {
return write!(f, "CaseMatch({:?})", inner)
}
if let Some(inner) = self.as_casgn() {
return write!(f, "Casgn({:?})", inner)
}
if let Some(inner) = self.as_cbase() {
return write!(f, "Cbase({:?})", inner)
}
if let Some(inner) = self.as_class() {
return write!(f, "Class({:?})", inner)
}
if let Some(inner) = self.as_complex() {
return write!(f, "Complex({:?})", inner)
}
if let Some(inner) = self.as_const() {
return write!(f, "Const({:?})", inner)
}
if let Some(inner) = self.as_const_pattern() {
return write!(f, "ConstPattern({:?})", inner)
}
if let Some(inner) = self.as_c_send() {
return write!(f, "CSend({:?})", inner)
}
if let Some(inner) = self.as_cvar() {
return write!(f, "Cvar({:?})", inner)
}
if let Some(inner) = self.as_cvasgn() {
return write!(f, "Cvasgn({:?})", inner)
}
if let Some(inner) = self.as_def() {
return write!(f, "Def({:?})", inner)
}
if let Some(inner) = self.as_defined() {
return write!(f, "Defined({:?})", inner)
}
if let Some(inner) = self.as_defs() {
return write!(f, "Defs({:?})", inner)
}
if let Some(inner) = self.as_dstr() {
return write!(f, "Dstr({:?})", inner)
}
if let Some(inner) = self.as_dsym() {
return write!(f, "Dsym({:?})", inner)
}
if let Some(inner) = self.as_e_flip_flop() {
return write!(f, "EFlipFlop({:?})", inner)
}
if let Some(inner) = self.as_empty_else() {
return write!(f, "EmptyElse({:?})", inner)
}
if let Some(inner) = self.as_encoding() {
return write!(f, "Encoding({:?})", inner)
}
if let Some(inner) = self.as_ensure() {
return write!(f, "Ensure({:?})", inner)
}
if let Some(inner) = self.as_erange() {
return write!(f, "Erange({:?})", inner)
}
if let Some(inner) = self.as_false() {
return write!(f, "False({:?})", inner)
}
if let Some(inner) = self.as_file() {
return write!(f, "File({:?})", inner)
}
if let Some(inner) = self.as_find_pattern() {
return write!(f, "FindPattern({:?})", inner)
}
if let Some(inner) = self.as_float() {
return write!(f, "Float({:?})", inner)
}
if let Some(inner) = self.as_for() {
return write!(f, "For({:?})", inner)
}
if let Some(inner) = self.as_forward_arg() {
return write!(f, "ForwardArg({:?})", inner)
}
if let Some(inner) = self.as_forwarded_args() {
return write!(f, "ForwardedArgs({:?})", inner)
}
if let Some(inner) = self.as_gvar() {
return write!(f, "Gvar({:?})", inner)
}
if let Some(inner) = self.as_gvasgn() {
return write!(f, "Gvasgn({:?})", inner)
}
if let Some(inner) = self.as_hash() {
return write!(f, "Hash({:?})", inner)
}
if let Some(inner) = self.as_hash_pattern() {
return write!(f, "HashPattern({:?})", inner)
}
if let Some(inner) = self.as_heredoc() {
return write!(f, "Heredoc({:?})", inner)
}
if let Some(inner) = self.as_if() {
return write!(f, "If({:?})", inner)
}
if let Some(inner) = self.as_if_guard() {
return write!(f, "IfGuard({:?})", inner)
}
if let Some(inner) = self.as_i_flip_flop() {
return write!(f, "IFlipFlop({:?})", inner)
}
if let Some(inner) = self.as_if_mod() {
return write!(f, "IfMod({:?})", inner)
}
if let Some(inner) = self.as_if_ternary() {
return write!(f, "IfTernary({:?})", inner)
}
if let Some(inner) = self.as_index() {
return write!(f, "Index({:?})", inner)
}
if let Some(inner) = self.as_index_asgn() {
return write!(f, "IndexAsgn({:?})", inner)
}
if let Some(inner) = self.as_in_pattern() {
return write!(f, "InPattern({:?})", inner)
}
if let Some(inner) = self.as_int() {
return write!(f, "Int({:?})", inner)
}
if let Some(inner) = self.as_irange() {
return write!(f, "Irange({:?})", inner)
}
if let Some(inner) = self.as_ivar() {
return write!(f, "Ivar({:?})", inner)
}
if let Some(inner) = self.as_ivasgn() {
return write!(f, "Ivasgn({:?})", inner)
}
if let Some(inner) = self.as_kwarg() {
return write!(f, "Kwarg({:?})", inner)
}
if let Some(inner) = self.as_kwargs() {
return write!(f, "Kwargs({:?})", inner)
}
if let Some(inner) = self.as_kw_begin() {
return write!(f, "KwBegin({:?})", inner)
}
if let Some(inner) = self.as_kwnilarg() {
return write!(f, "Kwnilarg({:?})", inner)
}
if let Some(inner) = self.as_kwoptarg() {
return write!(f, "Kwoptarg({:?})", inner)
}
if let Some(inner) = self.as_kwrestarg() {
return write!(f, "Kwrestarg({:?})", inner)
}
if let Some(inner) = self.as_kwsplat() {
return write!(f, "Kwsplat({:?})", inner)
}
if let Some(inner) = self.as_lambda() {
return write!(f, "Lambda({:?})", inner)
}
if let Some(inner) = self.as_line() {
return write!(f, "Line({:?})", inner)
}
if let Some(inner) = self.as_lvar() {
return write!(f, "Lvar({:?})", inner)
}
if let Some(inner) = self.as_lvasgn() {
return write!(f, "Lvasgn({:?})", inner)
}
if let Some(inner) = self.as_masgn() {
return write!(f, "Masgn({:?})", inner)
}
if let Some(inner) = self.as_match_alt() {
return write!(f, "MatchAlt({:?})", inner)
}
if let Some(inner) = self.as_match_as() {
return write!(f, "MatchAs({:?})", inner)
}
if let Some(inner) = self.as_match_current_line() {
return write!(f, "MatchCurrentLine({:?})", inner)
}
if let Some(inner) = self.as_match_nil_pattern() {
return write!(f, "MatchNilPattern({:?})", inner)
}
if let Some(inner) = self.as_match_pattern() {
return write!(f, "MatchPattern({:?})", inner)
}
if let Some(inner) = self.as_match_pattern_p() {
return write!(f, "MatchPatternP({:?})", inner)
}
if let Some(inner) = self.as_match_rest() {
return write!(f, "MatchRest({:?})", inner)
}
if let Some(inner) = self.as_match_var() {
return write!(f, "MatchVar({:?})", inner)
}
if let Some(inner) = self.as_match_with_lvasgn() {
return write!(f, "MatchWithLvasgn({:?})", inner)
}
if let Some(inner) = self.as_mlhs() {
return write!(f, "Mlhs({:?})", inner)
}
if let Some(inner) = self.as_module() {
return write!(f, "Module({:?})", inner)
}
if let Some(inner) = self.as_next() {
return write!(f, "Next({:?})", inner)
}
if let Some(inner) = self.as_nil() {
return write!(f, "Nil({:?})", inner)
}
if let Some(inner) = self.as_nth_ref() {
return write!(f, "NthRef({:?})", inner)
}
if let Some(inner) = self.as_numblock() {
return write!(f, "Numblock({:?})", inner)
}
if let Some(inner) = self.as_op_asgn() {
return write!(f, "OpAsgn({:?})", inner)
}
if let Some(inner) = self.as_optarg() {
return write!(f, "Optarg({:?})", inner)
}
if let Some(inner) = self.as_or() {
return write!(f, "Or({:?})", inner)
}
if let Some(inner) = self.as_or_asgn() {
return write!(f, "OrAsgn({:?})", inner)
}
if let Some(inner) = self.as_pair() {
return write!(f, "Pair({:?})", inner)
}
if let Some(inner) = self.as_pin() {
return write!(f, "Pin({:?})", inner)
}
if let Some(inner) = self.as_postexe() {
return write!(f, "Postexe({:?})", inner)
}
if let Some(inner) = self.as_preexe() {
return write!(f, "Preexe({:?})", inner)
}
if let Some(inner) = self.as_procarg0() {
return write!(f, "Procarg0({:?})", inner)
}
if let Some(inner) = self.as_rational() {
return write!(f, "Rational({:?})", inner)
}
if let Some(inner) = self.as_redo() {
return write!(f, "Redo({:?})", inner)
}
if let Some(inner) = self.as_regexp() {
return write!(f, "Regexp({:?})", inner)
}
if let Some(inner) = self.as_reg_opt() {
return write!(f, "RegOpt({:?})", inner)
}
if let Some(inner) = self.as_rescue() {
return write!(f, "Rescue({:?})", inner)
}
if let Some(inner) = self.as_rescue_body() {
return write!(f, "RescueBody({:?})", inner)
}
if let Some(inner) = self.as_restarg() {
return write!(f, "Restarg({:?})", inner)
}
if let Some(inner) = self.as_retry() {
return write!(f, "Retry({:?})", inner)
}
if let Some(inner) = self.as_return() {
return write!(f, "Return({:?})", inner)
}
if let Some(inner) = self.as_s_class() {
return write!(f, "SClass({:?})", inner)
}
if let Some(inner) = self.as_self_() {
return write!(f, "Self_({:?})", inner)
}
if let Some(inner) = self.as_send() {
return write!(f, "Send({:?})", inner)
}
if let Some(inner) = self.as_shadowarg() {
return write!(f, "Shadowarg({:?})", inner)
}
if let Some(inner) = self.as_splat() {
return write!(f, "Splat({:?})", inner)
}
if let Some(inner) = self.as_str() {
return write!(f, "Str({:?})", inner)
}
if let Some(inner) = self.as_super() {
return write!(f, "Super({:?})", inner)
}
if let Some(inner) = self.as_sym() {
return write!(f, "Sym({:?})", inner)
}
if let Some(inner) = self.as_true() {
return write!(f, "True({:?})", inner)
}
if let Some(inner) = self.as_undef() {
return write!(f, "Undef({:?})", inner)
}
if let Some(inner) = self.as_unless_guard() {
return write!(f, "UnlessGuard({:?})", inner)
}
if let Some(inner) = self.as_until() {
return write!(f, "Until({:?})", inner)
}
if let Some(inner) = self.as_until_post() {
return write!(f, "UntilPost({:?})", inner)
}
if let Some(inner) = self.as_when() {
return write!(f, "When({:?})", inner)
}
if let Some(inner) = self.as_while() {
return write!(f, "While({:?})", inner)
}
if let Some(inner) = self.as_while_post() {
return write!(f, "WhilePost({:?})", inner)
}
if let Some(inner) = self.as_x_heredoc() {
return write!(f, "XHeredoc({:?})", inner)
}
if let Some(inner) = self.as_xstr() {
return write!(f, "Xstr({:?})", inner)
}
if let Some(inner) = self.as_yield() {
return write!(f, "Yield({:?})", inner)
}
if let Some(inner) = self.as_z_super() {
return write!(f, "ZSuper({:?})", inner)
}
panic!("bug: unknown node type")
}
}
impl Clone for Node {
fn clone(&self) -> Self {
if let Some(inner) = self.as_alias() {
return Self::new_alias(
inner.get_to().clone(),
inner.get_from().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_and() {
return Self::new_and(
inner.get_lhs().clone(),
inner.get_rhs().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_and_asgn() {
return Self::new_and_asgn(
inner.get_recv().clone(),
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_arg() {
return Self::new_arg(
inner.get_name().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_args() {
return Self::new_args(
inner.get_args().clone(),
inner.get_expression_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
)
}
if let Some(inner) = self.as_array() {
return Self::new_array(
inner.get_elements().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_array_pattern() {
return Self::new_array_pattern(
inner.get_elements().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_array_pattern_with_tail() {
return Self::new_array_pattern_with_tail(
inner.get_elements().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_back_ref() {
return Self::new_back_ref(
inner.get_name().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_begin() {
return Self::new_begin(
inner.get_statements().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_block() {
return Self::new_block(
inner.get_call().clone(),
inner.get_args().clone(),
inner.get_body().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_blockarg() {
return Self::new_blockarg(
inner.get_name().clone(),
inner.get_operator_l().clone(),
inner.get_name_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_block_pass() {
return Self::new_block_pass(
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_break() {
return Self::new_break(
inner.get_args().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_case() {
return Self::new_case(
inner.get_expr().clone(),
inner.get_when_bodies().clone(),
inner.get_else_body().clone(),
inner.get_keyword_l().clone(),
inner.get_else_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_case_match() {
return Self::new_case_match(
inner.get_expr().clone(),
inner.get_in_bodies().clone(),
inner.get_else_body().clone(),
inner.get_keyword_l().clone(),
inner.get_else_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_casgn() {
return Self::new_casgn(
inner.get_scope().clone(),
inner.get_name().clone(),
inner.get_value().clone(),
inner.get_double_colon_l().clone(),
inner.get_name_l().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_cbase() {
return Self::new_cbase(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_class() {
return Self::new_class(
inner.get_name().clone(),
inner.get_superclass().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_operator_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_complex() {
return Self::new_complex(
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_const() {
return Self::new_const(
inner.get_scope().clone(),
inner.get_name().clone(),
inner.get_double_colon_l().clone(),
inner.get_name_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_const_pattern() {
return Self::new_const_pattern(
inner.get_const().clone(),
inner.get_pattern().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_c_send() {
return Self::new_c_send(
inner.get_recv().clone(),
inner.get_method_name().clone(),
inner.get_args().clone(),
inner.get_dot_l().clone(),
inner.get_selector_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_cvar() {
return Self::new_cvar(
inner.get_name().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_cvasgn() {
return Self::new_cvasgn(
inner.get_name().clone(),
inner.get_value().clone(),
inner.get_name_l().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_def() {
return Self::new_def(
inner.get_name().clone(),
inner.get_args().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_name_l().clone(),
inner.get_end_l().clone(),
inner.get_assignment_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_defined() {
return Self::new_defined(
inner.get_value().clone(),
inner.get_keyword_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_defs() {
return Self::new_defs(
inner.get_definee().clone(),
inner.get_name().clone(),
inner.get_args().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_operator_l().clone(),
inner.get_name_l().clone(),
inner.get_assignment_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_dstr() {
return Self::new_dstr(
inner.get_parts().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_dsym() {
return Self::new_dsym(
inner.get_parts().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_e_flip_flop() {
return Self::new_e_flip_flop(
inner.get_left().clone(),
inner.get_right().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_empty_else() {
return Self::new_empty_else(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_encoding() {
return Self::new_encoding(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_ensure() {
return Self::new_ensure(
inner.get_body().clone(),
inner.get_ensure().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_erange() {
return Self::new_erange(
inner.get_left().clone(),
inner.get_right().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_false() {
return Self::new_false(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_file() {
return Self::new_file(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_find_pattern() {
return Self::new_find_pattern(
inner.get_elements().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_float() {
return Self::new_float(
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_for() {
return Self::new_for(
inner.get_iterator().clone(),
inner.get_iteratee().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_operator_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_forward_arg() {
return Self::new_forward_arg(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_forwarded_args() {
return Self::new_forwarded_args(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_gvar() {
return Self::new_gvar(
inner.get_name().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_gvasgn() {
return Self::new_gvasgn(
inner.get_name().clone(),
inner.get_value().clone(),
inner.get_name_l().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_hash() {
return Self::new_hash(
inner.get_pairs().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_hash_pattern() {
return Self::new_hash_pattern(
inner.get_elements().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_heredoc() {
return Self::new_heredoc(
inner.get_parts().clone(),
inner.get_heredoc_body_l().clone(),
inner.get_heredoc_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_if() {
return Self::new_if(
inner.get_cond().clone(),
inner.get_if_true().clone(),
inner.get_if_false().clone(),
inner.get_keyword_l().clone(),
inner.get_begin_l().clone(),
inner.get_else_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_if_guard() {
return Self::new_if_guard(
inner.get_cond().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_i_flip_flop() {
return Self::new_i_flip_flop(
inner.get_left().clone(),
inner.get_right().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_if_mod() {
return Self::new_if_mod(
inner.get_cond().clone(),
inner.get_if_true().clone(),
inner.get_if_false().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_if_ternary() {
return Self::new_if_ternary(
inner.get_cond().clone(),
inner.get_if_true().clone(),
inner.get_if_false().clone(),
inner.get_question_l().clone(),
inner.get_colon_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_index() {
return Self::new_index(
inner.get_recv().clone(),
inner.get_indexes().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_index_asgn() {
return Self::new_index_asgn(
inner.get_recv().clone(),
inner.get_indexes().clone(),
inner.get_value().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_in_pattern() {
return Self::new_in_pattern(
inner.get_pattern().clone(),
inner.get_guard().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_begin_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_int() {
return Self::new_int(
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_irange() {
return Self::new_irange(
inner.get_left().clone(),
inner.get_right().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_ivar() {
return Self::new_ivar(
inner.get_name().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_ivasgn() {
return Self::new_ivasgn(
inner.get_name().clone(),
inner.get_value().clone(),
inner.get_name_l().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_kwarg() {
return Self::new_kwarg(
inner.get_name().clone(),
inner.get_name_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_kwargs() {
return Self::new_kwargs(
inner.get_pairs().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_kw_begin() {
return Self::new_kw_begin(
inner.get_statements().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_kwnilarg() {
return Self::new_kwnilarg(
inner.get_name_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_kwoptarg() {
return Self::new_kwoptarg(
inner.get_name().clone(),
inner.get_default().clone(),
inner.get_name_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_kwrestarg() {
return Self::new_kwrestarg(
inner.get_name().clone(),
inner.get_operator_l().clone(),
inner.get_name_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_kwsplat() {
return Self::new_kwsplat(
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_lambda() {
return Self::new_lambda(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_line() {
return Self::new_line(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_lvar() {
return Self::new_lvar(
inner.get_name().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_lvasgn() {
return Self::new_lvasgn(
inner.get_name().clone(),
inner.get_value().clone(),
inner.get_name_l().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_masgn() {
return Self::new_masgn(
inner.get_lhs().clone(),
inner.get_rhs().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_match_alt() {
return Self::new_match_alt(
inner.get_lhs().clone(),
inner.get_rhs().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_match_as() {
return Self::new_match_as(
inner.get_value().clone(),
inner.get_as().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_match_current_line() {
return Self::new_match_current_line(
inner.get_re().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_match_nil_pattern() {
return Self::new_match_nil_pattern(
inner.get_operator_l().clone(),
inner.get_name_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_match_pattern() {
return Self::new_match_pattern(
inner.get_value().clone(),
inner.get_pattern().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_match_pattern_p() {
return Self::new_match_pattern_p(
inner.get_value().clone(),
inner.get_pattern().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_match_rest() {
return Self::new_match_rest(
inner.get_name().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_match_var() {
return Self::new_match_var(
inner.get_name().clone(),
inner.get_name_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_match_with_lvasgn() {
return Self::new_match_with_lvasgn(
inner.get_re().clone(),
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_mlhs() {
return Self::new_mlhs(
inner.get_items().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_module() {
return Self::new_module(
inner.get_name().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_next() {
return Self::new_next(
inner.get_args().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_nil() {
return Self::new_nil(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_nth_ref() {
return Self::new_nth_ref(
inner.get_name().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_numblock() {
return Self::new_numblock(
inner.get_call().clone(),
inner.get_numargs().clone(),
inner.get_body().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_op_asgn() {
return Self::new_op_asgn(
inner.get_recv().clone(),
inner.get_operator().clone(),
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_optarg() {
return Self::new_optarg(
inner.get_name().clone(),
inner.get_default().clone(),
inner.get_name_l().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_or() {
return Self::new_or(
inner.get_lhs().clone(),
inner.get_rhs().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_or_asgn() {
return Self::new_or_asgn(
inner.get_recv().clone(),
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_pair() {
return Self::new_pair(
inner.get_key().clone(),
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_pin() {
return Self::new_pin(
inner.get_var().clone(),
inner.get_selector_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_postexe() {
return Self::new_postexe(
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_preexe() {
return Self::new_preexe(
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_procarg0() {
return Self::new_procarg0(
inner.get_args().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_rational() {
return Self::new_rational(
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_redo() {
return Self::new_redo(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_regexp() {
return Self::new_regexp(
inner.get_parts().clone(),
inner.get_options().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_reg_opt() {
return Self::new_reg_opt(
inner.get_options().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_rescue() {
return Self::new_rescue(
inner.get_body().clone(),
inner.get_rescue_bodies().clone(),
inner.get_else().clone(),
inner.get_else_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_rescue_body() {
return Self::new_rescue_body(
inner.get_exc_list().clone(),
inner.get_exc_var().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_assoc_l().clone(),
inner.get_begin_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_restarg() {
return Self::new_restarg(
inner.get_name().clone(),
inner.get_operator_l().clone(),
inner.get_name_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_retry() {
return Self::new_retry(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_return() {
return Self::new_return(
inner.get_args().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_s_class() {
return Self::new_s_class(
inner.get_expr().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_operator_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_self_() {
return Self::new_self_(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_send() {
return Self::new_send(
inner.get_recv().clone(),
inner.get_method_name().clone(),
inner.get_args().clone(),
inner.get_dot_l().clone(),
inner.get_selector_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_shadowarg() {
return Self::new_shadowarg(
inner.get_name().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_splat() {
return Self::new_splat(
inner.get_value().clone(),
inner.get_operator_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_str() {
return Self::new_str(
inner.get_value().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_super() {
return Self::new_super(
inner.get_args().clone(),
inner.get_keyword_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_sym() {
return Self::new_sym(
inner.get_name().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_true() {
return Self::new_true(
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_undef() {
return Self::new_undef(
inner.get_names().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_unless_guard() {
return Self::new_unless_guard(
inner.get_cond().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_until() {
return Self::new_until(
inner.get_cond().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_until_post() {
return Self::new_until_post(
inner.get_cond().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_when() {
return Self::new_when(
inner.get_patterns().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_begin_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_while() {
return Self::new_while(
inner.get_cond().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_while_post() {
return Self::new_while_post(
inner.get_cond().clone(),
inner.get_body().clone(),
inner.get_keyword_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_x_heredoc() {
return Self::new_x_heredoc(
inner.get_parts().clone(),
inner.get_heredoc_body_l().clone(),
inner.get_heredoc_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_xstr() {
return Self::new_xstr(
inner.get_parts().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_yield() {
return Self::new_yield(
inner.get_args().clone(),
inner.get_keyword_l().clone(),
inner.get_begin_l().clone(),
inner.get_end_l().clone(),
inner.get_expression_l().clone(),
)
}
if let Some(inner) = self.as_z_super() {
return Self::new_z_super(
inner.get_expression_l().clone(),
)
}
panic!("bug: unknown node type")
}
}
impl PartialEq for Node {
fn eq(&self, other: &Self) -> bool {
if let Some(lhs) = self.as_alias() {
if let Some(rhs) = other.as_alias() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_and() {
if let Some(rhs) = other.as_and() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_and_asgn() {
if let Some(rhs) = other.as_and_asgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_arg() {
if let Some(rhs) = other.as_arg() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_args() {
if let Some(rhs) = other.as_args() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_array() {
if let Some(rhs) = other.as_array() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_array_pattern() {
if let Some(rhs) = other.as_array_pattern() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_array_pattern_with_tail() {
if let Some(rhs) = other.as_array_pattern_with_tail() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_back_ref() {
if let Some(rhs) = other.as_back_ref() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_begin() {
if let Some(rhs) = other.as_begin() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_block() {
if let Some(rhs) = other.as_block() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_blockarg() {
if let Some(rhs) = other.as_blockarg() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_block_pass() {
if let Some(rhs) = other.as_block_pass() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_break() {
if let Some(rhs) = other.as_break() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_case() {
if let Some(rhs) = other.as_case() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_case_match() {
if let Some(rhs) = other.as_case_match() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_casgn() {
if let Some(rhs) = other.as_casgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_cbase() {
if let Some(rhs) = other.as_cbase() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_class() {
if let Some(rhs) = other.as_class() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_complex() {
if let Some(rhs) = other.as_complex() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_const() {
if let Some(rhs) = other.as_const() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_const_pattern() {
if let Some(rhs) = other.as_const_pattern() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_c_send() {
if let Some(rhs) = other.as_c_send() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_cvar() {
if let Some(rhs) = other.as_cvar() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_cvasgn() {
if let Some(rhs) = other.as_cvasgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_def() {
if let Some(rhs) = other.as_def() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_defined() {
if let Some(rhs) = other.as_defined() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_defs() {
if let Some(rhs) = other.as_defs() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_dstr() {
if let Some(rhs) = other.as_dstr() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_dsym() {
if let Some(rhs) = other.as_dsym() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_e_flip_flop() {
if let Some(rhs) = other.as_e_flip_flop() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_empty_else() {
if let Some(rhs) = other.as_empty_else() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_encoding() {
if let Some(rhs) = other.as_encoding() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_ensure() {
if let Some(rhs) = other.as_ensure() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_erange() {
if let Some(rhs) = other.as_erange() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_false() {
if let Some(rhs) = other.as_false() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_file() {
if let Some(rhs) = other.as_file() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_find_pattern() {
if let Some(rhs) = other.as_find_pattern() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_float() {
if let Some(rhs) = other.as_float() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_for() {
if let Some(rhs) = other.as_for() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_forward_arg() {
if let Some(rhs) = other.as_forward_arg() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_forwarded_args() {
if let Some(rhs) = other.as_forwarded_args() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_gvar() {
if let Some(rhs) = other.as_gvar() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_gvasgn() {
if let Some(rhs) = other.as_gvasgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_hash() {
if let Some(rhs) = other.as_hash() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_hash_pattern() {
if let Some(rhs) = other.as_hash_pattern() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_heredoc() {
if let Some(rhs) = other.as_heredoc() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_if() {
if let Some(rhs) = other.as_if() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_if_guard() {
if let Some(rhs) = other.as_if_guard() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_i_flip_flop() {
if let Some(rhs) = other.as_i_flip_flop() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_if_mod() {
if let Some(rhs) = other.as_if_mod() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_if_ternary() {
if let Some(rhs) = other.as_if_ternary() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_index() {
if let Some(rhs) = other.as_index() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_index_asgn() {
if let Some(rhs) = other.as_index_asgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_in_pattern() {
if let Some(rhs) = other.as_in_pattern() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_int() {
if let Some(rhs) = other.as_int() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_irange() {
if let Some(rhs) = other.as_irange() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_ivar() {
if let Some(rhs) = other.as_ivar() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_ivasgn() {
if let Some(rhs) = other.as_ivasgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_kwarg() {
if let Some(rhs) = other.as_kwarg() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_kwargs() {
if let Some(rhs) = other.as_kwargs() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_kw_begin() {
if let Some(rhs) = other.as_kw_begin() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_kwnilarg() {
if let Some(rhs) = other.as_kwnilarg() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_kwoptarg() {
if let Some(rhs) = other.as_kwoptarg() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_kwrestarg() {
if let Some(rhs) = other.as_kwrestarg() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_kwsplat() {
if let Some(rhs) = other.as_kwsplat() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_lambda() {
if let Some(rhs) = other.as_lambda() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_line() {
if let Some(rhs) = other.as_line() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_lvar() {
if let Some(rhs) = other.as_lvar() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_lvasgn() {
if let Some(rhs) = other.as_lvasgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_masgn() {
if let Some(rhs) = other.as_masgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_match_alt() {
if let Some(rhs) = other.as_match_alt() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_match_as() {
if let Some(rhs) = other.as_match_as() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_match_current_line() {
if let Some(rhs) = other.as_match_current_line() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_match_nil_pattern() {
if let Some(rhs) = other.as_match_nil_pattern() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_match_pattern() {
if let Some(rhs) = other.as_match_pattern() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_match_pattern_p() {
if let Some(rhs) = other.as_match_pattern_p() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_match_rest() {
if let Some(rhs) = other.as_match_rest() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_match_var() {
if let Some(rhs) = other.as_match_var() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_match_with_lvasgn() {
if let Some(rhs) = other.as_match_with_lvasgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_mlhs() {
if let Some(rhs) = other.as_mlhs() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_module() {
if let Some(rhs) = other.as_module() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_next() {
if let Some(rhs) = other.as_next() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_nil() {
if let Some(rhs) = other.as_nil() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_nth_ref() {
if let Some(rhs) = other.as_nth_ref() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_numblock() {
if let Some(rhs) = other.as_numblock() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_op_asgn() {
if let Some(rhs) = other.as_op_asgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_optarg() {
if let Some(rhs) = other.as_optarg() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_or() {
if let Some(rhs) = other.as_or() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_or_asgn() {
if let Some(rhs) = other.as_or_asgn() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_pair() {
if let Some(rhs) = other.as_pair() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_pin() {
if let Some(rhs) = other.as_pin() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_postexe() {
if let Some(rhs) = other.as_postexe() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_preexe() {
if let Some(rhs) = other.as_preexe() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_procarg0() {
if let Some(rhs) = other.as_procarg0() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_rational() {
if let Some(rhs) = other.as_rational() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_redo() {
if let Some(rhs) = other.as_redo() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_regexp() {
if let Some(rhs) = other.as_regexp() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_reg_opt() {
if let Some(rhs) = other.as_reg_opt() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_rescue() {
if let Some(rhs) = other.as_rescue() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_rescue_body() {
if let Some(rhs) = other.as_rescue_body() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_restarg() {
if let Some(rhs) = other.as_restarg() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_retry() {
if let Some(rhs) = other.as_retry() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_return() {
if let Some(rhs) = other.as_return() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_s_class() {
if let Some(rhs) = other.as_s_class() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_self_() {
if let Some(rhs) = other.as_self_() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_send() {
if let Some(rhs) = other.as_send() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_shadowarg() {
if let Some(rhs) = other.as_shadowarg() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_splat() {
if let Some(rhs) = other.as_splat() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_str() {
if let Some(rhs) = other.as_str() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_super() {
if let Some(rhs) = other.as_super() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_sym() {
if let Some(rhs) = other.as_sym() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_true() {
if let Some(rhs) = other.as_true() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_undef() {
if let Some(rhs) = other.as_undef() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_unless_guard() {
if let Some(rhs) = other.as_unless_guard() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_until() {
if let Some(rhs) = other.as_until() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_until_post() {
if let Some(rhs) = other.as_until_post() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_when() {
if let Some(rhs) = other.as_when() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_while() {
if let Some(rhs) = other.as_while() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_while_post() {
if let Some(rhs) = other.as_while_post() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_x_heredoc() {
if let Some(rhs) = other.as_x_heredoc() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_xstr() {
if let Some(rhs) = other.as_xstr() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_yield() {
if let Some(rhs) = other.as_yield() {
return lhs == rhs;
} else {
return false;
}
}
if let Some(lhs) = self.as_z_super() {
if let Some(rhs) = other.as_z_super() {
return lhs == rhs;
} else {
return false;
}
}
panic!("bug: unknown node type")
}
}
impl Node {
pub(crate) fn inner_ref(&self) -> &dyn InnerNode {
if let Some(inner) = self.as_alias() {
return inner;
}
if let Some(inner) = self.as_and() {
return inner;
}
if let Some(inner) = self.as_and_asgn() {
return inner;
}
if let Some(inner) = self.as_arg() {
return inner;
}
if let Some(inner) = self.as_args() {
return inner;
}
if let Some(inner) = self.as_array() {
return inner;
}
if let Some(inner) = self.as_array_pattern() {
return inner;
}
if let Some(inner) = self.as_array_pattern_with_tail() {
return inner;
}
if let Some(inner) = self.as_back_ref() {
return inner;
}
if let Some(inner) = self.as_begin() {
return inner;
}
if let Some(inner) = self.as_block() {
return inner;
}
if let Some(inner) = self.as_blockarg() {
return inner;
}
if let Some(inner) = self.as_block_pass() {
return inner;
}
if let Some(inner) = self.as_break() {
return inner;
}
if let Some(inner) = self.as_case() {
return inner;
}
if let Some(inner) = self.as_case_match() {
return inner;
}
if let Some(inner) = self.as_casgn() {
return inner;
}
if let Some(inner) = self.as_cbase() {
return inner;
}
if let Some(inner) = self.as_class() {
return inner;
}
if let Some(inner) = self.as_complex() {
return inner;
}
if let Some(inner) = self.as_const() {
return inner;
}
if let Some(inner) = self.as_const_pattern() {
return inner;
}
if let Some(inner) = self.as_c_send() {
return inner;
}
if let Some(inner) = self.as_cvar() {
return inner;
}
if let Some(inner) = self.as_cvasgn() {
return inner;
}
if let Some(inner) = self.as_def() {
return inner;
}
if let Some(inner) = self.as_defined() {
return inner;
}
if let Some(inner) = self.as_defs() {
return inner;
}
if let Some(inner) = self.as_dstr() {
return inner;
}
if let Some(inner) = self.as_dsym() {
return inner;
}
if let Some(inner) = self.as_e_flip_flop() {
return inner;
}
if let Some(inner) = self.as_empty_else() {
return inner;
}
if let Some(inner) = self.as_encoding() {
return inner;
}
if let Some(inner) = self.as_ensure() {
return inner;
}
if let Some(inner) = self.as_erange() {
return inner;
}
if let Some(inner) = self.as_false() {
return inner;
}
if let Some(inner) = self.as_file() {
return inner;
}
if let Some(inner) = self.as_find_pattern() {
return inner;
}
if let Some(inner) = self.as_float() {
return inner;
}
if let Some(inner) = self.as_for() {
return inner;
}
if let Some(inner) = self.as_forward_arg() {
return inner;
}
if let Some(inner) = self.as_forwarded_args() {
return inner;
}
if let Some(inner) = self.as_gvar() {
return inner;
}
if let Some(inner) = self.as_gvasgn() {
return inner;
}
if let Some(inner) = self.as_hash() {
return inner;
}
if let Some(inner) = self.as_hash_pattern() {
return inner;
}
if let Some(inner) = self.as_heredoc() {
return inner;
}
if let Some(inner) = self.as_if() {
return inner;
}
if let Some(inner) = self.as_if_guard() {
return inner;
}
if let Some(inner) = self.as_i_flip_flop() {
return inner;
}
if let Some(inner) = self.as_if_mod() {
return inner;
}
if let Some(inner) = self.as_if_ternary() {
return inner;
}
if let Some(inner) = self.as_index() {
return inner;
}
if let Some(inner) = self.as_index_asgn() {
return inner;
}
if let Some(inner) = self.as_in_pattern() {
return inner;
}
if let Some(inner) = self.as_int() {
return inner;
}
if let Some(inner) = self.as_irange() {
return inner;
}
if let Some(inner) = self.as_ivar() {
return inner;
}
if let Some(inner) = self.as_ivasgn() {
return inner;
}
if let Some(inner) = self.as_kwarg() {
return inner;
}
if let Some(inner) = self.as_kwargs() {
return inner;
}
if let Some(inner) = self.as_kw_begin() {
return inner;
}
if let Some(inner) = self.as_kwnilarg() {
return inner;
}
if let Some(inner) = self.as_kwoptarg() {
return inner;
}
if let Some(inner) = self.as_kwrestarg() {
return inner;
}
if let Some(inner) = self.as_kwsplat() {
return inner;
}
if let Some(inner) = self.as_lambda() {
return inner;
}
if let Some(inner) = self.as_line() {
return inner;
}
if let Some(inner) = self.as_lvar() {
return inner;
}
if let Some(inner) = self.as_lvasgn() {
return inner;
}
if let Some(inner) = self.as_masgn() {
return inner;
}
if let Some(inner) = self.as_match_alt() {
return inner;
}
if let Some(inner) = self.as_match_as() {
return inner;
}
if let Some(inner) = self.as_match_current_line() {
return inner;
}
if let Some(inner) = self.as_match_nil_pattern() {
return inner;
}
if let Some(inner) = self.as_match_pattern() {
return inner;
}
if let Some(inner) = self.as_match_pattern_p() {
return inner;
}
if let Some(inner) = self.as_match_rest() {
return inner;
}
if let Some(inner) = self.as_match_var() {
return inner;
}
if let Some(inner) = self.as_match_with_lvasgn() {
return inner;
}
if let Some(inner) = self.as_mlhs() {
return inner;
}
if let Some(inner) = self.as_module() {
return inner;
}
if let Some(inner) = self.as_next() {
return inner;
}
if let Some(inner) = self.as_nil() {
return inner;
}
if let Some(inner) = self.as_nth_ref() {
return inner;
}
if let Some(inner) = self.as_numblock() {
return inner;
}
if let Some(inner) = self.as_op_asgn() {
return inner;
}
if let Some(inner) = self.as_optarg() {
return inner;
}
if let Some(inner) = self.as_or() {
return inner;
}
if let Some(inner) = self.as_or_asgn() {
return inner;
}
if let Some(inner) = self.as_pair() {
return inner;
}
if let Some(inner) = self.as_pin() {
return inner;
}
if let Some(inner) = self.as_postexe() {
return inner;
}
if let Some(inner) = self.as_preexe() {
return inner;
}
if let Some(inner) = self.as_procarg0() {
return inner;
}
if let Some(inner) = self.as_rational() {
return inner;
}
if let Some(inner) = self.as_redo() {
return inner;
}
if let Some(inner) = self.as_regexp() {
return inner;
}
if let Some(inner) = self.as_reg_opt() {
return inner;
}
if let Some(inner) = self.as_rescue() {
return inner;
}
if let Some(inner) = self.as_rescue_body() {
return inner;
}
if let Some(inner) = self.as_restarg() {
return inner;
}
if let Some(inner) = self.as_retry() {
return inner;
}
if let Some(inner) = self.as_return() {
return inner;
}
if let Some(inner) = self.as_s_class() {
return inner;
}
if let Some(inner) = self.as_self_() {
return inner;
}
if let Some(inner) = self.as_send() {
return inner;
}
if let Some(inner) = self.as_shadowarg() {
return inner;
}
if let Some(inner) = self.as_splat() {
return inner;
}
if let Some(inner) = self.as_str() {
return inner;
}
if let Some(inner) = self.as_super() {
return inner;
}
if let Some(inner) = self.as_sym() {
return inner;
}
if let Some(inner) = self.as_true() {
return inner;
}
if let Some(inner) = self.as_undef() {
return inner;
}
if let Some(inner) = self.as_unless_guard() {
return inner;
}
if let Some(inner) = self.as_until() {
return inner;
}
if let Some(inner) = self.as_until_post() {
return inner;
}
if let Some(inner) = self.as_when() {
return inner;
}
if let Some(inner) = self.as_while() {
return inner;
}
if let Some(inner) = self.as_while_post() {
return inner;
}
if let Some(inner) = self.as_x_heredoc() {
return inner;
}
if let Some(inner) = self.as_xstr() {
return inner;
}
if let Some(inner) = self.as_yield() {
return inner;
}
if let Some(inner) = self.as_z_super() {
return inner;
}
panic!("bug: unknown node type")
}
pub(crate) fn new_alias(to: Ptr<Node>, from: Ptr<Node>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_alias(to.into_blob(), from.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_and(lhs: Ptr<Node>, rhs: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_and(lhs.into_blob(), rhs.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_and_asgn(recv: Ptr<Node>, value: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_and_asgn(recv.into_blob(), value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_arg(name: StringPtr, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_arg(name.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_args(args: List<Node>, expression_l: Loc, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_args(args.into_blob(), expression_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_array(elements: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_array(elements.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_array_pattern(elements: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_array_pattern(elements.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_array_pattern_with_tail(elements: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_array_pattern_with_tail(elements.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_back_ref(name: StringPtr, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_back_ref(name.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_begin(statements: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_begin(statements.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_block(call: Ptr<Node>, args: Maybe<Ptr<Node>>, body: Maybe<Ptr<Node>>, begin_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_block(call.into_blob(), args.into_blob(), body.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_blockarg(name: StringPtr, operator_l: Loc, name_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_blockarg(name.into_blob(), operator_l.into_blob(), name_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_block_pass(value: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_block_pass(value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_break(args: List<Node>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_break(args.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_case(expr: Maybe<Ptr<Node>>, when_bodies: List<Node>, else_body: Maybe<Ptr<Node>>, keyword_l: Loc, else_l: Maybe<Loc>, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_case(expr.into_blob(), when_bodies.into_blob(), else_body.into_blob(), keyword_l.into_blob(), else_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_case_match(expr: Ptr<Node>, in_bodies: List<Node>, else_body: Maybe<Ptr<Node>>, keyword_l: Loc, else_l: Maybe<Loc>, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_case_match(expr.into_blob(), in_bodies.into_blob(), else_body.into_blob(), keyword_l.into_blob(), else_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_casgn(scope: Maybe<Ptr<Node>>, name: StringPtr, value: Maybe<Ptr<Node>>, double_colon_l: Maybe<Loc>, name_l: Loc, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_casgn(scope.into_blob(), name.into_blob(), value.into_blob(), double_colon_l.into_blob(), name_l.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_cbase(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_cbase(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_class(name: Ptr<Node>, superclass: Maybe<Ptr<Node>>, body: Maybe<Ptr<Node>>, keyword_l: Loc, operator_l: Maybe<Loc>, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_class(name.into_blob(), superclass.into_blob(), body.into_blob(), keyword_l.into_blob(), operator_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_complex(value: StringPtr, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_complex(value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_const(scope: Maybe<Ptr<Node>>, name: StringPtr, double_colon_l: Maybe<Loc>, name_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_const(scope.into_blob(), name.into_blob(), double_colon_l.into_blob(), name_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_const_pattern(const_: Ptr<Node>, pattern: Ptr<Node>, begin_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_const_pattern(const_.into_blob(), pattern.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_c_send(recv: Ptr<Node>, method_name: StringPtr, args: List<Node>, dot_l: Loc, selector_l: Maybe<Loc>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_c_send(recv.into_blob(), method_name.into_blob(), args.into_blob(), dot_l.into_blob(), selector_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_cvar(name: StringPtr, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_cvar(name.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_cvasgn(name: StringPtr, value: Maybe<Ptr<Node>>, name_l: Loc, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_cvasgn(name.into_blob(), value.into_blob(), name_l.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_def(name: StringPtr, args: Maybe<Ptr<Node>>, body: Maybe<Ptr<Node>>, keyword_l: Loc, name_l: Loc, end_l: Maybe<Loc>, assignment_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_def(name.into_blob(), args.into_blob(), body.into_blob(), keyword_l.into_blob(), name_l.into_blob(), end_l.into_blob(), assignment_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_defined(value: Ptr<Node>, keyword_l: Loc, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_defined(value.into_blob(), keyword_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_defs(definee: Ptr<Node>, name: StringPtr, args: Maybe<Ptr<Node>>, body: Maybe<Ptr<Node>>, keyword_l: Loc, operator_l: Loc, name_l: Loc, assignment_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_defs(definee.into_blob(), name.into_blob(), args.into_blob(), body.into_blob(), keyword_l.into_blob(), operator_l.into_blob(), name_l.into_blob(), assignment_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_dstr(parts: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_dstr(parts.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_dsym(parts: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_dsym(parts.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_e_flip_flop(left: Maybe<Ptr<Node>>, right: Maybe<Ptr<Node>>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_e_flip_flop(left.into_blob(), right.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_empty_else(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_empty_else(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_encoding(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_encoding(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_ensure(body: Maybe<Ptr<Node>>, ensure: Maybe<Ptr<Node>>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_ensure(body.into_blob(), ensure.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_erange(left: Maybe<Ptr<Node>>, right: Maybe<Ptr<Node>>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_erange(left.into_blob(), right.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_false(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_false(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_file(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_file(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_find_pattern(elements: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_find_pattern(elements.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_float(value: StringPtr, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_float(value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_for(iterator: Ptr<Node>, iteratee: Ptr<Node>, body: Maybe<Ptr<Node>>, keyword_l: Loc, operator_l: Loc, begin_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_for(iterator.into_blob(), iteratee.into_blob(), body.into_blob(), keyword_l.into_blob(), operator_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_forward_arg(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_forward_arg(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_forwarded_args(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_forwarded_args(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_gvar(name: StringPtr, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_gvar(name.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_gvasgn(name: StringPtr, value: Maybe<Ptr<Node>>, name_l: Loc, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_gvasgn(name.into_blob(), value.into_blob(), name_l.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_hash(pairs: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_hash(pairs.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_hash_pattern(elements: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_hash_pattern(elements.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_heredoc(parts: List<Node>, heredoc_body_l: Loc, heredoc_end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_heredoc(parts.into_blob(), heredoc_body_l.into_blob(), heredoc_end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_if(cond: Ptr<Node>, if_true: Maybe<Ptr<Node>>, if_false: Maybe<Ptr<Node>>, keyword_l: Loc, begin_l: Loc, else_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_if(cond.into_blob(), if_true.into_blob(), if_false.into_blob(), keyword_l.into_blob(), begin_l.into_blob(), else_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_if_guard(cond: Ptr<Node>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_if_guard(cond.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_i_flip_flop(left: Maybe<Ptr<Node>>, right: Maybe<Ptr<Node>>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_i_flip_flop(left.into_blob(), right.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_if_mod(cond: Ptr<Node>, if_true: Maybe<Ptr<Node>>, if_false: Maybe<Ptr<Node>>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_if_mod(cond.into_blob(), if_true.into_blob(), if_false.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_if_ternary(cond: Ptr<Node>, if_true: Ptr<Node>, if_false: Ptr<Node>, question_l: Loc, colon_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_if_ternary(cond.into_blob(), if_true.into_blob(), if_false.into_blob(), question_l.into_blob(), colon_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_index(recv: Ptr<Node>, indexes: List<Node>, begin_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_index(recv.into_blob(), indexes.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_index_asgn(recv: Ptr<Node>, indexes: List<Node>, value: Maybe<Ptr<Node>>, begin_l: Loc, end_l: Loc, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_index_asgn(recv.into_blob(), indexes.into_blob(), value.into_blob(), begin_l.into_blob(), end_l.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_in_pattern(pattern: Ptr<Node>, guard: Maybe<Ptr<Node>>, body: Maybe<Ptr<Node>>, keyword_l: Loc, begin_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_in_pattern(pattern.into_blob(), guard.into_blob(), body.into_blob(), keyword_l.into_blob(), begin_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_int(value: StringPtr, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_int(value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_irange(left: Maybe<Ptr<Node>>, right: Maybe<Ptr<Node>>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_irange(left.into_blob(), right.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_ivar(name: StringPtr, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_ivar(name.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_ivasgn(name: StringPtr, value: Maybe<Ptr<Node>>, name_l: Loc, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_ivasgn(name.into_blob(), value.into_blob(), name_l.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_kwarg(name: StringPtr, name_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_kwarg(name.into_blob(), name_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_kwargs(pairs: List<Node>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_kwargs(pairs.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_kw_begin(statements: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_kw_begin(statements.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_kwnilarg(name_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_kwnilarg(name_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_kwoptarg(name: StringPtr, default: Ptr<Node>, name_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_kwoptarg(name.into_blob(), default.into_blob(), name_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_kwrestarg(name: Maybe<StringPtr>, operator_l: Loc, name_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_kwrestarg(name.into_blob(), operator_l.into_blob(), name_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_kwsplat(value: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_kwsplat(value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_lambda(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_lambda(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_line(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_line(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_lvar(name: StringPtr, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_lvar(name.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_lvasgn(name: StringPtr, value: Maybe<Ptr<Node>>, name_l: Loc, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_lvasgn(name.into_blob(), value.into_blob(), name_l.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_masgn(lhs: Ptr<Node>, rhs: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_masgn(lhs.into_blob(), rhs.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_match_alt(lhs: Ptr<Node>, rhs: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_match_alt(lhs.into_blob(), rhs.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_match_as(value: Ptr<Node>, as_: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_match_as(value.into_blob(), as_.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_match_current_line(re: Ptr<Node>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_match_current_line(re.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_match_nil_pattern(operator_l: Loc, name_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_match_nil_pattern(operator_l.into_blob(), name_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_match_pattern(value: Ptr<Node>, pattern: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_match_pattern(value.into_blob(), pattern.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_match_pattern_p(value: Ptr<Node>, pattern: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_match_pattern_p(value.into_blob(), pattern.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_match_rest(name: Maybe<Ptr<Node>>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_match_rest(name.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_match_var(name: StringPtr, name_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_match_var(name.into_blob(), name_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_match_with_lvasgn(re: Ptr<Node>, value: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_match_with_lvasgn(re.into_blob(), value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_mlhs(items: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_mlhs(items.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_module(name: Ptr<Node>, body: Maybe<Ptr<Node>>, keyword_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_module(name.into_blob(), body.into_blob(), keyword_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_next(args: List<Node>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_next(args.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_nil(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_nil(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_nth_ref(name: StringPtr, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_nth_ref(name.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_numblock(call: Ptr<Node>, numargs: u8, body: Ptr<Node>, begin_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_numblock(call.into_blob(), numargs.into_blob(), body.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_op_asgn(recv: Ptr<Node>, operator: StringPtr, value: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_op_asgn(recv.into_blob(), operator.into_blob(), value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_optarg(name: StringPtr, default: Ptr<Node>, name_l: Loc, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_optarg(name.into_blob(), default.into_blob(), name_l.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_or(lhs: Ptr<Node>, rhs: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_or(lhs.into_blob(), rhs.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_or_asgn(recv: Ptr<Node>, value: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_or_asgn(recv.into_blob(), value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_pair(key: Ptr<Node>, value: Ptr<Node>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_pair(key.into_blob(), value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_pin(var: Ptr<Node>, selector_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_pin(var.into_blob(), selector_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_postexe(body: Maybe<Ptr<Node>>, keyword_l: Loc, begin_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_postexe(body.into_blob(), keyword_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_preexe(body: Maybe<Ptr<Node>>, keyword_l: Loc, begin_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_preexe(body.into_blob(), keyword_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_procarg0(args: List<Node>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_procarg0(args.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_rational(value: StringPtr, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_rational(value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_redo(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_redo(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_regexp(parts: List<Node>, options: Maybe<Ptr<Node>>, begin_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_regexp(parts.into_blob(), options.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_reg_opt(options: Maybe<StringPtr>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_reg_opt(options.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_rescue(body: Maybe<Ptr<Node>>, rescue_bodies: List<Node>, else_: Maybe<Ptr<Node>>, else_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_rescue(body.into_blob(), rescue_bodies.into_blob(), else_.into_blob(), else_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_rescue_body(exc_list: Maybe<Ptr<Node>>, exc_var: Maybe<Ptr<Node>>, body: Maybe<Ptr<Node>>, keyword_l: Loc, assoc_l: Maybe<Loc>, begin_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_rescue_body(exc_list.into_blob(), exc_var.into_blob(), body.into_blob(), keyword_l.into_blob(), assoc_l.into_blob(), begin_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_restarg(name: Maybe<StringPtr>, operator_l: Loc, name_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_restarg(name.into_blob(), operator_l.into_blob(), name_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_retry(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_retry(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_return(args: List<Node>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_return(args.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_s_class(expr: Ptr<Node>, body: Maybe<Ptr<Node>>, keyword_l: Loc, operator_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_s_class(expr.into_blob(), body.into_blob(), keyword_l.into_blob(), operator_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_self_(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_self_(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_send(recv: Maybe<Ptr<Node>>, method_name: StringPtr, args: List<Node>, dot_l: Maybe<Loc>, selector_l: Maybe<Loc>, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, operator_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_send(recv.into_blob(), method_name.into_blob(), args.into_blob(), dot_l.into_blob(), selector_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_shadowarg(name: StringPtr, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_shadowarg(name.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_splat(value: Maybe<Ptr<Node>>, operator_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_splat(value.into_blob(), operator_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_str(value: Bytes, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_str(value.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_super(args: List<Node>, keyword_l: Loc, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_super(args.into_blob(), keyword_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_sym(name: Bytes, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_sym(name.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_true(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_true(expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_undef(names: List<Node>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_undef(names.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_unless_guard(cond: Ptr<Node>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_unless_guard(cond.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_until(cond: Ptr<Node>, body: Maybe<Ptr<Node>>, keyword_l: Loc, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_until(cond.into_blob(), body.into_blob(), keyword_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_until_post(cond: Ptr<Node>, body: Ptr<Node>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_until_post(cond.into_blob(), body.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_when(patterns: List<Node>, body: Maybe<Ptr<Node>>, keyword_l: Loc, begin_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_when(patterns.into_blob(), body.into_blob(), keyword_l.into_blob(), begin_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_while(cond: Ptr<Node>, body: Maybe<Ptr<Node>>, keyword_l: Loc, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_while(cond.into_blob(), body.into_blob(), keyword_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_while_post(cond: Ptr<Node>, body: Ptr<Node>, keyword_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_while_post(cond.into_blob(), body.into_blob(), keyword_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_x_heredoc(parts: List<Node>, heredoc_body_l: Loc, heredoc_end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_x_heredoc(parts.into_blob(), heredoc_body_l.into_blob(), heredoc_end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_xstr(parts: List<Node>, begin_l: Loc, end_l: Loc, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_xstr(parts.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_yield(args: List<Node>, keyword_l: Loc, begin_l: Maybe<Loc>, end_l: Maybe<Loc>, expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_yield(args.into_blob(), keyword_l.into_blob(), begin_l.into_blob(), end_l.into_blob(), expression_l.into_blob(), ) };
Self { blob }
}
pub(crate) fn new_z_super(expression_l: Loc, ) -> Self {
let blob = unsafe { lib_ruby_parser__external__nodes__new_z_super(expression_l.into_blob(), ) };
Self { blob }
}
pub fn is_alias(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_alias(&self.blob) }
}
pub fn is_and(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_and(&self.blob) }
}
pub fn is_and_asgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_and_asgn(&self.blob) }
}
pub fn is_arg(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_arg(&self.blob) }
}
pub fn is_args(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_args(&self.blob) }
}
pub fn is_array(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_array(&self.blob) }
}
pub fn is_array_pattern(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_array_pattern(&self.blob) }
}
pub fn is_array_pattern_with_tail(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_array_pattern_with_tail(&self.blob) }
}
pub fn is_back_ref(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_back_ref(&self.blob) }
}
pub fn is_begin(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_begin(&self.blob) }
}
pub fn is_block(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_block(&self.blob) }
}
pub fn is_blockarg(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_blockarg(&self.blob) }
}
pub fn is_block_pass(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_block_pass(&self.blob) }
}
pub fn is_break(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_break(&self.blob) }
}
pub fn is_case(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_case(&self.blob) }
}
pub fn is_case_match(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_case_match(&self.blob) }
}
pub fn is_casgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_casgn(&self.blob) }
}
pub fn is_cbase(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_cbase(&self.blob) }
}
pub fn is_class(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_class(&self.blob) }
}
pub fn is_complex(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_complex(&self.blob) }
}
pub fn is_const(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_const(&self.blob) }
}
pub fn is_const_pattern(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_const_pattern(&self.blob) }
}
pub fn is_c_send(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_c_send(&self.blob) }
}
pub fn is_cvar(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_cvar(&self.blob) }
}
pub fn is_cvasgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_cvasgn(&self.blob) }
}
pub fn is_def(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_def(&self.blob) }
}
pub fn is_defined(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_defined(&self.blob) }
}
pub fn is_defs(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_defs(&self.blob) }
}
pub fn is_dstr(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_dstr(&self.blob) }
}
pub fn is_dsym(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_dsym(&self.blob) }
}
pub fn is_e_flip_flop(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_e_flip_flop(&self.blob) }
}
pub fn is_empty_else(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_empty_else(&self.blob) }
}
pub fn is_encoding(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_encoding(&self.blob) }
}
pub fn is_ensure(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_ensure(&self.blob) }
}
pub fn is_erange(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_erange(&self.blob) }
}
pub fn is_false(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_false(&self.blob) }
}
pub fn is_file(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_file(&self.blob) }
}
pub fn is_find_pattern(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_find_pattern(&self.blob) }
}
pub fn is_float(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_float(&self.blob) }
}
pub fn is_for(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_for(&self.blob) }
}
pub fn is_forward_arg(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_forward_arg(&self.blob) }
}
pub fn is_forwarded_args(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_forwarded_args(&self.blob) }
}
pub fn is_gvar(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_gvar(&self.blob) }
}
pub fn is_gvasgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_gvasgn(&self.blob) }
}
pub fn is_hash(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_hash(&self.blob) }
}
pub fn is_hash_pattern(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_hash_pattern(&self.blob) }
}
pub fn is_heredoc(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_heredoc(&self.blob) }
}
pub fn is_if(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_if(&self.blob) }
}
pub fn is_if_guard(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_if_guard(&self.blob) }
}
pub fn is_i_flip_flop(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_i_flip_flop(&self.blob) }
}
pub fn is_if_mod(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_if_mod(&self.blob) }
}
pub fn is_if_ternary(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_if_ternary(&self.blob) }
}
pub fn is_index(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_index(&self.blob) }
}
pub fn is_index_asgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_index_asgn(&self.blob) }
}
pub fn is_in_pattern(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_in_pattern(&self.blob) }
}
pub fn is_int(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_int(&self.blob) }
}
pub fn is_irange(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_irange(&self.blob) }
}
pub fn is_ivar(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_ivar(&self.blob) }
}
pub fn is_ivasgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_ivasgn(&self.blob) }
}
pub fn is_kwarg(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_kwarg(&self.blob) }
}
pub fn is_kwargs(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_kwargs(&self.blob) }
}
pub fn is_kw_begin(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_kw_begin(&self.blob) }
}
pub fn is_kwnilarg(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_kwnilarg(&self.blob) }
}
pub fn is_kwoptarg(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_kwoptarg(&self.blob) }
}
pub fn is_kwrestarg(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_kwrestarg(&self.blob) }
}
pub fn is_kwsplat(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_kwsplat(&self.blob) }
}
pub fn is_lambda(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_lambda(&self.blob) }
}
pub fn is_line(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_line(&self.blob) }
}
pub fn is_lvar(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_lvar(&self.blob) }
}
pub fn is_lvasgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_lvasgn(&self.blob) }
}
pub fn is_masgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_masgn(&self.blob) }
}
pub fn is_match_alt(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_match_alt(&self.blob) }
}
pub fn is_match_as(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_match_as(&self.blob) }
}
pub fn is_match_current_line(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_match_current_line(&self.blob) }
}
pub fn is_match_nil_pattern(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_match_nil_pattern(&self.blob) }
}
pub fn is_match_pattern(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_match_pattern(&self.blob) }
}
pub fn is_match_pattern_p(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_match_pattern_p(&self.blob) }
}
pub fn is_match_rest(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_match_rest(&self.blob) }
}
pub fn is_match_var(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_match_var(&self.blob) }
}
pub fn is_match_with_lvasgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_match_with_lvasgn(&self.blob) }
}
pub fn is_mlhs(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_mlhs(&self.blob) }
}
pub fn is_module(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_module(&self.blob) }
}
pub fn is_next(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_next(&self.blob) }
}
pub fn is_nil(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_nil(&self.blob) }
}
pub fn is_nth_ref(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_nth_ref(&self.blob) }
}
pub fn is_numblock(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_numblock(&self.blob) }
}
pub fn is_op_asgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_op_asgn(&self.blob) }
}
pub fn is_optarg(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_optarg(&self.blob) }
}
pub fn is_or(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_or(&self.blob) }
}
pub fn is_or_asgn(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_or_asgn(&self.blob) }
}
pub fn is_pair(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_pair(&self.blob) }
}
pub fn is_pin(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_pin(&self.blob) }
}
pub fn is_postexe(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_postexe(&self.blob) }
}
pub fn is_preexe(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_preexe(&self.blob) }
}
pub fn is_procarg0(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_procarg0(&self.blob) }
}
pub fn is_rational(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_rational(&self.blob) }
}
pub fn is_redo(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_redo(&self.blob) }
}
pub fn is_regexp(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_regexp(&self.blob) }
}
pub fn is_reg_opt(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_reg_opt(&self.blob) }
}
pub fn is_rescue(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_rescue(&self.blob) }
}
pub fn is_rescue_body(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_rescue_body(&self.blob) }
}
pub fn is_restarg(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_restarg(&self.blob) }
}
pub fn is_retry(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_retry(&self.blob) }
}
pub fn is_return(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_return(&self.blob) }
}
pub fn is_s_class(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_s_class(&self.blob) }
}
pub fn is_self_(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_self_(&self.blob) }
}
pub fn is_send(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_send(&self.blob) }
}
pub fn is_shadowarg(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_shadowarg(&self.blob) }
}
pub fn is_splat(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_splat(&self.blob) }
}
pub fn is_str(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_str(&self.blob) }
}
pub fn is_super(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_super(&self.blob) }
}
pub fn is_sym(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_sym(&self.blob) }
}
pub fn is_true(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_true(&self.blob) }
}
pub fn is_undef(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_undef(&self.blob) }
}
pub fn is_unless_guard(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_unless_guard(&self.blob) }
}
pub fn is_until(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_until(&self.blob) }
}
pub fn is_until_post(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_until_post(&self.blob) }
}
pub fn is_when(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_when(&self.blob) }
}
pub fn is_while(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_while(&self.blob) }
}
pub fn is_while_post(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_while_post(&self.blob) }
}
pub fn is_x_heredoc(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_x_heredoc(&self.blob) }
}
pub fn is_xstr(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_xstr(&self.blob) }
}
pub fn is_yield(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_yield(&self.blob) }
}
pub fn is_z_super(&self) -> bool {
unsafe { lib_ruby_parser__external__nodes__is_z_super(&self.blob) }
}
pub fn as_alias(&self) -> Option<&Alias> {
unsafe { (lib_ruby_parser__external__nodes__get_alias(&self.blob) as *const Alias).as_ref() }
}
pub fn as_and(&self) -> Option<&And> {
unsafe { (lib_ruby_parser__external__nodes__get_and(&self.blob) as *const And).as_ref() }
}
pub fn as_and_asgn(&self) -> Option<&AndAsgn> {
unsafe { (lib_ruby_parser__external__nodes__get_and_asgn(&self.blob) as *const AndAsgn).as_ref() }
}
pub fn as_arg(&self) -> Option<&Arg> {
unsafe { (lib_ruby_parser__external__nodes__get_arg(&self.blob) as *const Arg).as_ref() }
}
pub fn as_args(&self) -> Option<&Args> {
unsafe { (lib_ruby_parser__external__nodes__get_args(&self.blob) as *const Args).as_ref() }
}
pub fn as_array(&self) -> Option<&Array> {
unsafe { (lib_ruby_parser__external__nodes__get_array(&self.blob) as *const Array).as_ref() }
}
pub fn as_array_pattern(&self) -> Option<&ArrayPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_array_pattern(&self.blob) as *const ArrayPattern).as_ref() }
}
pub fn as_array_pattern_with_tail(&self) -> Option<&ArrayPatternWithTail> {
unsafe { (lib_ruby_parser__external__nodes__get_array_pattern_with_tail(&self.blob) as *const ArrayPatternWithTail).as_ref() }
}
pub fn as_back_ref(&self) -> Option<&BackRef> {
unsafe { (lib_ruby_parser__external__nodes__get_back_ref(&self.blob) as *const BackRef).as_ref() }
}
pub fn as_begin(&self) -> Option<&Begin> {
unsafe { (lib_ruby_parser__external__nodes__get_begin(&self.blob) as *const Begin).as_ref() }
}
pub fn as_block(&self) -> Option<&Block> {
unsafe { (lib_ruby_parser__external__nodes__get_block(&self.blob) as *const Block).as_ref() }
}
pub fn as_blockarg(&self) -> Option<&Blockarg> {
unsafe { (lib_ruby_parser__external__nodes__get_blockarg(&self.blob) as *const Blockarg).as_ref() }
}
pub fn as_block_pass(&self) -> Option<&BlockPass> {
unsafe { (lib_ruby_parser__external__nodes__get_block_pass(&self.blob) as *const BlockPass).as_ref() }
}
pub fn as_break(&self) -> Option<&Break> {
unsafe { (lib_ruby_parser__external__nodes__get_break(&self.blob) as *const Break).as_ref() }
}
pub fn as_case(&self) -> Option<&Case> {
unsafe { (lib_ruby_parser__external__nodes__get_case(&self.blob) as *const Case).as_ref() }
}
pub fn as_case_match(&self) -> Option<&CaseMatch> {
unsafe { (lib_ruby_parser__external__nodes__get_case_match(&self.blob) as *const CaseMatch).as_ref() }
}
pub fn as_casgn(&self) -> Option<&Casgn> {
unsafe { (lib_ruby_parser__external__nodes__get_casgn(&self.blob) as *const Casgn).as_ref() }
}
pub fn as_cbase(&self) -> Option<&Cbase> {
unsafe { (lib_ruby_parser__external__nodes__get_cbase(&self.blob) as *const Cbase).as_ref() }
}
pub fn as_class(&self) -> Option<&Class> {
unsafe { (lib_ruby_parser__external__nodes__get_class(&self.blob) as *const Class).as_ref() }
}
pub fn as_complex(&self) -> Option<&Complex> {
unsafe { (lib_ruby_parser__external__nodes__get_complex(&self.blob) as *const Complex).as_ref() }
}
pub fn as_const(&self) -> Option<&Const> {
unsafe { (lib_ruby_parser__external__nodes__get_const(&self.blob) as *const Const).as_ref() }
}
pub fn as_const_pattern(&self) -> Option<&ConstPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_const_pattern(&self.blob) as *const ConstPattern).as_ref() }
}
pub fn as_c_send(&self) -> Option<&CSend> {
unsafe { (lib_ruby_parser__external__nodes__get_c_send(&self.blob) as *const CSend).as_ref() }
}
pub fn as_cvar(&self) -> Option<&Cvar> {
unsafe { (lib_ruby_parser__external__nodes__get_cvar(&self.blob) as *const Cvar).as_ref() }
}
pub fn as_cvasgn(&self) -> Option<&Cvasgn> {
unsafe { (lib_ruby_parser__external__nodes__get_cvasgn(&self.blob) as *const Cvasgn).as_ref() }
}
pub fn as_def(&self) -> Option<&Def> {
unsafe { (lib_ruby_parser__external__nodes__get_def(&self.blob) as *const Def).as_ref() }
}
pub fn as_defined(&self) -> Option<&Defined> {
unsafe { (lib_ruby_parser__external__nodes__get_defined(&self.blob) as *const Defined).as_ref() }
}
pub fn as_defs(&self) -> Option<&Defs> {
unsafe { (lib_ruby_parser__external__nodes__get_defs(&self.blob) as *const Defs).as_ref() }
}
pub fn as_dstr(&self) -> Option<&Dstr> {
unsafe { (lib_ruby_parser__external__nodes__get_dstr(&self.blob) as *const Dstr).as_ref() }
}
pub fn as_dsym(&self) -> Option<&Dsym> {
unsafe { (lib_ruby_parser__external__nodes__get_dsym(&self.blob) as *const Dsym).as_ref() }
}
pub fn as_e_flip_flop(&self) -> Option<&EFlipFlop> {
unsafe { (lib_ruby_parser__external__nodes__get_e_flip_flop(&self.blob) as *const EFlipFlop).as_ref() }
}
pub fn as_empty_else(&self) -> Option<&EmptyElse> {
unsafe { (lib_ruby_parser__external__nodes__get_empty_else(&self.blob) as *const EmptyElse).as_ref() }
}
pub fn as_encoding(&self) -> Option<&Encoding> {
unsafe { (lib_ruby_parser__external__nodes__get_encoding(&self.blob) as *const Encoding).as_ref() }
}
pub fn as_ensure(&self) -> Option<&Ensure> {
unsafe { (lib_ruby_parser__external__nodes__get_ensure(&self.blob) as *const Ensure).as_ref() }
}
pub fn as_erange(&self) -> Option<&Erange> {
unsafe { (lib_ruby_parser__external__nodes__get_erange(&self.blob) as *const Erange).as_ref() }
}
pub fn as_false(&self) -> Option<&False> {
unsafe { (lib_ruby_parser__external__nodes__get_false(&self.blob) as *const False).as_ref() }
}
pub fn as_file(&self) -> Option<&File> {
unsafe { (lib_ruby_parser__external__nodes__get_file(&self.blob) as *const File).as_ref() }
}
pub fn as_find_pattern(&self) -> Option<&FindPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_find_pattern(&self.blob) as *const FindPattern).as_ref() }
}
pub fn as_float(&self) -> Option<&Float> {
unsafe { (lib_ruby_parser__external__nodes__get_float(&self.blob) as *const Float).as_ref() }
}
pub fn as_for(&self) -> Option<&For> {
unsafe { (lib_ruby_parser__external__nodes__get_for(&self.blob) as *const For).as_ref() }
}
pub fn as_forward_arg(&self) -> Option<&ForwardArg> {
unsafe { (lib_ruby_parser__external__nodes__get_forward_arg(&self.blob) as *const ForwardArg).as_ref() }
}
pub fn as_forwarded_args(&self) -> Option<&ForwardedArgs> {
unsafe { (lib_ruby_parser__external__nodes__get_forwarded_args(&self.blob) as *const ForwardedArgs).as_ref() }
}
pub fn as_gvar(&self) -> Option<&Gvar> {
unsafe { (lib_ruby_parser__external__nodes__get_gvar(&self.blob) as *const Gvar).as_ref() }
}
pub fn as_gvasgn(&self) -> Option<&Gvasgn> {
unsafe { (lib_ruby_parser__external__nodes__get_gvasgn(&self.blob) as *const Gvasgn).as_ref() }
}
pub fn as_hash(&self) -> Option<&Hash> {
unsafe { (lib_ruby_parser__external__nodes__get_hash(&self.blob) as *const Hash).as_ref() }
}
pub fn as_hash_pattern(&self) -> Option<&HashPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_hash_pattern(&self.blob) as *const HashPattern).as_ref() }
}
pub fn as_heredoc(&self) -> Option<&Heredoc> {
unsafe { (lib_ruby_parser__external__nodes__get_heredoc(&self.blob) as *const Heredoc).as_ref() }
}
pub fn as_if(&self) -> Option<&If> {
unsafe { (lib_ruby_parser__external__nodes__get_if(&self.blob) as *const If).as_ref() }
}
pub fn as_if_guard(&self) -> Option<&IfGuard> {
unsafe { (lib_ruby_parser__external__nodes__get_if_guard(&self.blob) as *const IfGuard).as_ref() }
}
pub fn as_i_flip_flop(&self) -> Option<&IFlipFlop> {
unsafe { (lib_ruby_parser__external__nodes__get_i_flip_flop(&self.blob) as *const IFlipFlop).as_ref() }
}
pub fn as_if_mod(&self) -> Option<&IfMod> {
unsafe { (lib_ruby_parser__external__nodes__get_if_mod(&self.blob) as *const IfMod).as_ref() }
}
pub fn as_if_ternary(&self) -> Option<&IfTernary> {
unsafe { (lib_ruby_parser__external__nodes__get_if_ternary(&self.blob) as *const IfTernary).as_ref() }
}
pub fn as_index(&self) -> Option<&Index> {
unsafe { (lib_ruby_parser__external__nodes__get_index(&self.blob) as *const Index).as_ref() }
}
pub fn as_index_asgn(&self) -> Option<&IndexAsgn> {
unsafe { (lib_ruby_parser__external__nodes__get_index_asgn(&self.blob) as *const IndexAsgn).as_ref() }
}
pub fn as_in_pattern(&self) -> Option<&InPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_in_pattern(&self.blob) as *const InPattern).as_ref() }
}
pub fn as_int(&self) -> Option<&Int> {
unsafe { (lib_ruby_parser__external__nodes__get_int(&self.blob) as *const Int).as_ref() }
}
pub fn as_irange(&self) -> Option<&Irange> {
unsafe { (lib_ruby_parser__external__nodes__get_irange(&self.blob) as *const Irange).as_ref() }
}
pub fn as_ivar(&self) -> Option<&Ivar> {
unsafe { (lib_ruby_parser__external__nodes__get_ivar(&self.blob) as *const Ivar).as_ref() }
}
pub fn as_ivasgn(&self) -> Option<&Ivasgn> {
unsafe { (lib_ruby_parser__external__nodes__get_ivasgn(&self.blob) as *const Ivasgn).as_ref() }
}
pub fn as_kwarg(&self) -> Option<&Kwarg> {
unsafe { (lib_ruby_parser__external__nodes__get_kwarg(&self.blob) as *const Kwarg).as_ref() }
}
pub fn as_kwargs(&self) -> Option<&Kwargs> {
unsafe { (lib_ruby_parser__external__nodes__get_kwargs(&self.blob) as *const Kwargs).as_ref() }
}
pub fn as_kw_begin(&self) -> Option<&KwBegin> {
unsafe { (lib_ruby_parser__external__nodes__get_kw_begin(&self.blob) as *const KwBegin).as_ref() }
}
pub fn as_kwnilarg(&self) -> Option<&Kwnilarg> {
unsafe { (lib_ruby_parser__external__nodes__get_kwnilarg(&self.blob) as *const Kwnilarg).as_ref() }
}
pub fn as_kwoptarg(&self) -> Option<&Kwoptarg> {
unsafe { (lib_ruby_parser__external__nodes__get_kwoptarg(&self.blob) as *const Kwoptarg).as_ref() }
}
pub fn as_kwrestarg(&self) -> Option<&Kwrestarg> {
unsafe { (lib_ruby_parser__external__nodes__get_kwrestarg(&self.blob) as *const Kwrestarg).as_ref() }
}
pub fn as_kwsplat(&self) -> Option<&Kwsplat> {
unsafe { (lib_ruby_parser__external__nodes__get_kwsplat(&self.blob) as *const Kwsplat).as_ref() }
}
pub fn as_lambda(&self) -> Option<&Lambda> {
unsafe { (lib_ruby_parser__external__nodes__get_lambda(&self.blob) as *const Lambda).as_ref() }
}
pub fn as_line(&self) -> Option<&Line> {
unsafe { (lib_ruby_parser__external__nodes__get_line(&self.blob) as *const Line).as_ref() }
}
pub fn as_lvar(&self) -> Option<&Lvar> {
unsafe { (lib_ruby_parser__external__nodes__get_lvar(&self.blob) as *const Lvar).as_ref() }
}
pub fn as_lvasgn(&self) -> Option<&Lvasgn> {
unsafe { (lib_ruby_parser__external__nodes__get_lvasgn(&self.blob) as *const Lvasgn).as_ref() }
}
pub fn as_masgn(&self) -> Option<&Masgn> {
unsafe { (lib_ruby_parser__external__nodes__get_masgn(&self.blob) as *const Masgn).as_ref() }
}
pub fn as_match_alt(&self) -> Option<&MatchAlt> {
unsafe { (lib_ruby_parser__external__nodes__get_match_alt(&self.blob) as *const MatchAlt).as_ref() }
}
pub fn as_match_as(&self) -> Option<&MatchAs> {
unsafe { (lib_ruby_parser__external__nodes__get_match_as(&self.blob) as *const MatchAs).as_ref() }
}
pub fn as_match_current_line(&self) -> Option<&MatchCurrentLine> {
unsafe { (lib_ruby_parser__external__nodes__get_match_current_line(&self.blob) as *const MatchCurrentLine).as_ref() }
}
pub fn as_match_nil_pattern(&self) -> Option<&MatchNilPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_match_nil_pattern(&self.blob) as *const MatchNilPattern).as_ref() }
}
pub fn as_match_pattern(&self) -> Option<&MatchPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_match_pattern(&self.blob) as *const MatchPattern).as_ref() }
}
pub fn as_match_pattern_p(&self) -> Option<&MatchPatternP> {
unsafe { (lib_ruby_parser__external__nodes__get_match_pattern_p(&self.blob) as *const MatchPatternP).as_ref() }
}
pub fn as_match_rest(&self) -> Option<&MatchRest> {
unsafe { (lib_ruby_parser__external__nodes__get_match_rest(&self.blob) as *const MatchRest).as_ref() }
}
pub fn as_match_var(&self) -> Option<&MatchVar> {
unsafe { (lib_ruby_parser__external__nodes__get_match_var(&self.blob) as *const MatchVar).as_ref() }
}
pub fn as_match_with_lvasgn(&self) -> Option<&MatchWithLvasgn> {
unsafe { (lib_ruby_parser__external__nodes__get_match_with_lvasgn(&self.blob) as *const MatchWithLvasgn).as_ref() }
}
pub fn as_mlhs(&self) -> Option<&Mlhs> {
unsafe { (lib_ruby_parser__external__nodes__get_mlhs(&self.blob) as *const Mlhs).as_ref() }
}
pub fn as_module(&self) -> Option<&Module> {
unsafe { (lib_ruby_parser__external__nodes__get_module(&self.blob) as *const Module).as_ref() }
}
pub fn as_next(&self) -> Option<&Next> {
unsafe { (lib_ruby_parser__external__nodes__get_next(&self.blob) as *const Next).as_ref() }
}
pub fn as_nil(&self) -> Option<&Nil> {
unsafe { (lib_ruby_parser__external__nodes__get_nil(&self.blob) as *const Nil).as_ref() }
}
pub fn as_nth_ref(&self) -> Option<&NthRef> {
unsafe { (lib_ruby_parser__external__nodes__get_nth_ref(&self.blob) as *const NthRef).as_ref() }
}
pub fn as_numblock(&self) -> Option<&Numblock> {
unsafe { (lib_ruby_parser__external__nodes__get_numblock(&self.blob) as *const Numblock).as_ref() }
}
pub fn as_op_asgn(&self) -> Option<&OpAsgn> {
unsafe { (lib_ruby_parser__external__nodes__get_op_asgn(&self.blob) as *const OpAsgn).as_ref() }
}
pub fn as_optarg(&self) -> Option<&Optarg> {
unsafe { (lib_ruby_parser__external__nodes__get_optarg(&self.blob) as *const Optarg).as_ref() }
}
pub fn as_or(&self) -> Option<&Or> {
unsafe { (lib_ruby_parser__external__nodes__get_or(&self.blob) as *const Or).as_ref() }
}
pub fn as_or_asgn(&self) -> Option<&OrAsgn> {
unsafe { (lib_ruby_parser__external__nodes__get_or_asgn(&self.blob) as *const OrAsgn).as_ref() }
}
pub fn as_pair(&self) -> Option<&Pair> {
unsafe { (lib_ruby_parser__external__nodes__get_pair(&self.blob) as *const Pair).as_ref() }
}
pub fn as_pin(&self) -> Option<&Pin> {
unsafe { (lib_ruby_parser__external__nodes__get_pin(&self.blob) as *const Pin).as_ref() }
}
pub fn as_postexe(&self) -> Option<&Postexe> {
unsafe { (lib_ruby_parser__external__nodes__get_postexe(&self.blob) as *const Postexe).as_ref() }
}
pub fn as_preexe(&self) -> Option<&Preexe> {
unsafe { (lib_ruby_parser__external__nodes__get_preexe(&self.blob) as *const Preexe).as_ref() }
}
pub fn as_procarg0(&self) -> Option<&Procarg0> {
unsafe { (lib_ruby_parser__external__nodes__get_procarg0(&self.blob) as *const Procarg0).as_ref() }
}
pub fn as_rational(&self) -> Option<&Rational> {
unsafe { (lib_ruby_parser__external__nodes__get_rational(&self.blob) as *const Rational).as_ref() }
}
pub fn as_redo(&self) -> Option<&Redo> {
unsafe { (lib_ruby_parser__external__nodes__get_redo(&self.blob) as *const Redo).as_ref() }
}
pub fn as_regexp(&self) -> Option<&Regexp> {
unsafe { (lib_ruby_parser__external__nodes__get_regexp(&self.blob) as *const Regexp).as_ref() }
}
pub fn as_reg_opt(&self) -> Option<&RegOpt> {
unsafe { (lib_ruby_parser__external__nodes__get_reg_opt(&self.blob) as *const RegOpt).as_ref() }
}
pub fn as_rescue(&self) -> Option<&Rescue> {
unsafe { (lib_ruby_parser__external__nodes__get_rescue(&self.blob) as *const Rescue).as_ref() }
}
pub fn as_rescue_body(&self) -> Option<&RescueBody> {
unsafe { (lib_ruby_parser__external__nodes__get_rescue_body(&self.blob) as *const RescueBody).as_ref() }
}
pub fn as_restarg(&self) -> Option<&Restarg> {
unsafe { (lib_ruby_parser__external__nodes__get_restarg(&self.blob) as *const Restarg).as_ref() }
}
pub fn as_retry(&self) -> Option<&Retry> {
unsafe { (lib_ruby_parser__external__nodes__get_retry(&self.blob) as *const Retry).as_ref() }
}
pub fn as_return(&self) -> Option<&Return> {
unsafe { (lib_ruby_parser__external__nodes__get_return(&self.blob) as *const Return).as_ref() }
}
pub fn as_s_class(&self) -> Option<&SClass> {
unsafe { (lib_ruby_parser__external__nodes__get_s_class(&self.blob) as *const SClass).as_ref() }
}
pub fn as_self_(&self) -> Option<&Self_> {
unsafe { (lib_ruby_parser__external__nodes__get_self_(&self.blob) as *const Self_).as_ref() }
}
pub fn as_send(&self) -> Option<&Send> {
unsafe { (lib_ruby_parser__external__nodes__get_send(&self.blob) as *const Send).as_ref() }
}
pub fn as_shadowarg(&self) -> Option<&Shadowarg> {
unsafe { (lib_ruby_parser__external__nodes__get_shadowarg(&self.blob) as *const Shadowarg).as_ref() }
}
pub fn as_splat(&self) -> Option<&Splat> {
unsafe { (lib_ruby_parser__external__nodes__get_splat(&self.blob) as *const Splat).as_ref() }
}
pub fn as_str(&self) -> Option<&Str> {
unsafe { (lib_ruby_parser__external__nodes__get_str(&self.blob) as *const Str).as_ref() }
}
pub fn as_super(&self) -> Option<&Super> {
unsafe { (lib_ruby_parser__external__nodes__get_super(&self.blob) as *const Super).as_ref() }
}
pub fn as_sym(&self) -> Option<&Sym> {
unsafe { (lib_ruby_parser__external__nodes__get_sym(&self.blob) as *const Sym).as_ref() }
}
pub fn as_true(&self) -> Option<&True> {
unsafe { (lib_ruby_parser__external__nodes__get_true(&self.blob) as *const True).as_ref() }
}
pub fn as_undef(&self) -> Option<&Undef> {
unsafe { (lib_ruby_parser__external__nodes__get_undef(&self.blob) as *const Undef).as_ref() }
}
pub fn as_unless_guard(&self) -> Option<&UnlessGuard> {
unsafe { (lib_ruby_parser__external__nodes__get_unless_guard(&self.blob) as *const UnlessGuard).as_ref() }
}
pub fn as_until(&self) -> Option<&Until> {
unsafe { (lib_ruby_parser__external__nodes__get_until(&self.blob) as *const Until).as_ref() }
}
pub fn as_until_post(&self) -> Option<&UntilPost> {
unsafe { (lib_ruby_parser__external__nodes__get_until_post(&self.blob) as *const UntilPost).as_ref() }
}
pub fn as_when(&self) -> Option<&When> {
unsafe { (lib_ruby_parser__external__nodes__get_when(&self.blob) as *const When).as_ref() }
}
pub fn as_while(&self) -> Option<&While> {
unsafe { (lib_ruby_parser__external__nodes__get_while(&self.blob) as *const While).as_ref() }
}
pub fn as_while_post(&self) -> Option<&WhilePost> {
unsafe { (lib_ruby_parser__external__nodes__get_while_post(&self.blob) as *const WhilePost).as_ref() }
}
pub fn as_x_heredoc(&self) -> Option<&XHeredoc> {
unsafe { (lib_ruby_parser__external__nodes__get_x_heredoc(&self.blob) as *const XHeredoc).as_ref() }
}
pub fn as_xstr(&self) -> Option<&Xstr> {
unsafe { (lib_ruby_parser__external__nodes__get_xstr(&self.blob) as *const Xstr).as_ref() }
}
pub fn as_yield(&self) -> Option<&Yield> {
unsafe { (lib_ruby_parser__external__nodes__get_yield(&self.blob) as *const Yield).as_ref() }
}
pub fn as_z_super(&self) -> Option<&ZSuper> {
unsafe { (lib_ruby_parser__external__nodes__get_z_super(&self.blob) as *const ZSuper).as_ref() }
}
#[allow(non_snake_case)]
pub fn as_alias_mut(&mut self) -> Option<&mut Alias> {
unsafe { (lib_ruby_parser__external__nodes__get_alias(&self.blob) as *mut Alias).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_and_mut(&mut self) -> Option<&mut And> {
unsafe { (lib_ruby_parser__external__nodes__get_and(&self.blob) as *mut And).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_and_asgn_mut(&mut self) -> Option<&mut AndAsgn> {
unsafe { (lib_ruby_parser__external__nodes__get_and_asgn(&self.blob) as *mut AndAsgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_arg_mut(&mut self) -> Option<&mut Arg> {
unsafe { (lib_ruby_parser__external__nodes__get_arg(&self.blob) as *mut Arg).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_args_mut(&mut self) -> Option<&mut Args> {
unsafe { (lib_ruby_parser__external__nodes__get_args(&self.blob) as *mut Args).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_array_mut(&mut self) -> Option<&mut Array> {
unsafe { (lib_ruby_parser__external__nodes__get_array(&self.blob) as *mut Array).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_array_pattern_mut(&mut self) -> Option<&mut ArrayPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_array_pattern(&self.blob) as *mut ArrayPattern).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_array_pattern_with_tail_mut(&mut self) -> Option<&mut ArrayPatternWithTail> {
unsafe { (lib_ruby_parser__external__nodes__get_array_pattern_with_tail(&self.blob) as *mut ArrayPatternWithTail).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_back_ref_mut(&mut self) -> Option<&mut BackRef> {
unsafe { (lib_ruby_parser__external__nodes__get_back_ref(&self.blob) as *mut BackRef).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_begin_mut(&mut self) -> Option<&mut Begin> {
unsafe { (lib_ruby_parser__external__nodes__get_begin(&self.blob) as *mut Begin).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_block_mut(&mut self) -> Option<&mut Block> {
unsafe { (lib_ruby_parser__external__nodes__get_block(&self.blob) as *mut Block).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_blockarg_mut(&mut self) -> Option<&mut Blockarg> {
unsafe { (lib_ruby_parser__external__nodes__get_blockarg(&self.blob) as *mut Blockarg).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_block_pass_mut(&mut self) -> Option<&mut BlockPass> {
unsafe { (lib_ruby_parser__external__nodes__get_block_pass(&self.blob) as *mut BlockPass).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_break_mut(&mut self) -> Option<&mut Break> {
unsafe { (lib_ruby_parser__external__nodes__get_break(&self.blob) as *mut Break).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_case_mut(&mut self) -> Option<&mut Case> {
unsafe { (lib_ruby_parser__external__nodes__get_case(&self.blob) as *mut Case).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_case_match_mut(&mut self) -> Option<&mut CaseMatch> {
unsafe { (lib_ruby_parser__external__nodes__get_case_match(&self.blob) as *mut CaseMatch).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_casgn_mut(&mut self) -> Option<&mut Casgn> {
unsafe { (lib_ruby_parser__external__nodes__get_casgn(&self.blob) as *mut Casgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_cbase_mut(&mut self) -> Option<&mut Cbase> {
unsafe { (lib_ruby_parser__external__nodes__get_cbase(&self.blob) as *mut Cbase).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_class_mut(&mut self) -> Option<&mut Class> {
unsafe { (lib_ruby_parser__external__nodes__get_class(&self.blob) as *mut Class).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_complex_mut(&mut self) -> Option<&mut Complex> {
unsafe { (lib_ruby_parser__external__nodes__get_complex(&self.blob) as *mut Complex).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_const_mut(&mut self) -> Option<&mut Const> {
unsafe { (lib_ruby_parser__external__nodes__get_const(&self.blob) as *mut Const).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_const_pattern_mut(&mut self) -> Option<&mut ConstPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_const_pattern(&self.blob) as *mut ConstPattern).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_c_send_mut(&mut self) -> Option<&mut CSend> {
unsafe { (lib_ruby_parser__external__nodes__get_c_send(&self.blob) as *mut CSend).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_cvar_mut(&mut self) -> Option<&mut Cvar> {
unsafe { (lib_ruby_parser__external__nodes__get_cvar(&self.blob) as *mut Cvar).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_cvasgn_mut(&mut self) -> Option<&mut Cvasgn> {
unsafe { (lib_ruby_parser__external__nodes__get_cvasgn(&self.blob) as *mut Cvasgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_def_mut(&mut self) -> Option<&mut Def> {
unsafe { (lib_ruby_parser__external__nodes__get_def(&self.blob) as *mut Def).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_defined_mut(&mut self) -> Option<&mut Defined> {
unsafe { (lib_ruby_parser__external__nodes__get_defined(&self.blob) as *mut Defined).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_defs_mut(&mut self) -> Option<&mut Defs> {
unsafe { (lib_ruby_parser__external__nodes__get_defs(&self.blob) as *mut Defs).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_dstr_mut(&mut self) -> Option<&mut Dstr> {
unsafe { (lib_ruby_parser__external__nodes__get_dstr(&self.blob) as *mut Dstr).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_dsym_mut(&mut self) -> Option<&mut Dsym> {
unsafe { (lib_ruby_parser__external__nodes__get_dsym(&self.blob) as *mut Dsym).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_e_flip_flop_mut(&mut self) -> Option<&mut EFlipFlop> {
unsafe { (lib_ruby_parser__external__nodes__get_e_flip_flop(&self.blob) as *mut EFlipFlop).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_empty_else_mut(&mut self) -> Option<&mut EmptyElse> {
unsafe { (lib_ruby_parser__external__nodes__get_empty_else(&self.blob) as *mut EmptyElse).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_encoding_mut(&mut self) -> Option<&mut Encoding> {
unsafe { (lib_ruby_parser__external__nodes__get_encoding(&self.blob) as *mut Encoding).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_ensure_mut(&mut self) -> Option<&mut Ensure> {
unsafe { (lib_ruby_parser__external__nodes__get_ensure(&self.blob) as *mut Ensure).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_erange_mut(&mut self) -> Option<&mut Erange> {
unsafe { (lib_ruby_parser__external__nodes__get_erange(&self.blob) as *mut Erange).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_false_mut(&mut self) -> Option<&mut False> {
unsafe { (lib_ruby_parser__external__nodes__get_false(&self.blob) as *mut False).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_file_mut(&mut self) -> Option<&mut File> {
unsafe { (lib_ruby_parser__external__nodes__get_file(&self.blob) as *mut File).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_find_pattern_mut(&mut self) -> Option<&mut FindPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_find_pattern(&self.blob) as *mut FindPattern).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_float_mut(&mut self) -> Option<&mut Float> {
unsafe { (lib_ruby_parser__external__nodes__get_float(&self.blob) as *mut Float).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_for_mut(&mut self) -> Option<&mut For> {
unsafe { (lib_ruby_parser__external__nodes__get_for(&self.blob) as *mut For).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_forward_arg_mut(&mut self) -> Option<&mut ForwardArg> {
unsafe { (lib_ruby_parser__external__nodes__get_forward_arg(&self.blob) as *mut ForwardArg).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_forwarded_args_mut(&mut self) -> Option<&mut ForwardedArgs> {
unsafe { (lib_ruby_parser__external__nodes__get_forwarded_args(&self.blob) as *mut ForwardedArgs).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_gvar_mut(&mut self) -> Option<&mut Gvar> {
unsafe { (lib_ruby_parser__external__nodes__get_gvar(&self.blob) as *mut Gvar).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_gvasgn_mut(&mut self) -> Option<&mut Gvasgn> {
unsafe { (lib_ruby_parser__external__nodes__get_gvasgn(&self.blob) as *mut Gvasgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_hash_mut(&mut self) -> Option<&mut Hash> {
unsafe { (lib_ruby_parser__external__nodes__get_hash(&self.blob) as *mut Hash).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_hash_pattern_mut(&mut self) -> Option<&mut HashPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_hash_pattern(&self.blob) as *mut HashPattern).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_heredoc_mut(&mut self) -> Option<&mut Heredoc> {
unsafe { (lib_ruby_parser__external__nodes__get_heredoc(&self.blob) as *mut Heredoc).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_if_mut(&mut self) -> Option<&mut If> {
unsafe { (lib_ruby_parser__external__nodes__get_if(&self.blob) as *mut If).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_if_guard_mut(&mut self) -> Option<&mut IfGuard> {
unsafe { (lib_ruby_parser__external__nodes__get_if_guard(&self.blob) as *mut IfGuard).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_i_flip_flop_mut(&mut self) -> Option<&mut IFlipFlop> {
unsafe { (lib_ruby_parser__external__nodes__get_i_flip_flop(&self.blob) as *mut IFlipFlop).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_if_mod_mut(&mut self) -> Option<&mut IfMod> {
unsafe { (lib_ruby_parser__external__nodes__get_if_mod(&self.blob) as *mut IfMod).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_if_ternary_mut(&mut self) -> Option<&mut IfTernary> {
unsafe { (lib_ruby_parser__external__nodes__get_if_ternary(&self.blob) as *mut IfTernary).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_index_mut(&mut self) -> Option<&mut Index> {
unsafe { (lib_ruby_parser__external__nodes__get_index(&self.blob) as *mut Index).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_index_asgn_mut(&mut self) -> Option<&mut IndexAsgn> {
unsafe { (lib_ruby_parser__external__nodes__get_index_asgn(&self.blob) as *mut IndexAsgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_in_pattern_mut(&mut self) -> Option<&mut InPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_in_pattern(&self.blob) as *mut InPattern).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_int_mut(&mut self) -> Option<&mut Int> {
unsafe { (lib_ruby_parser__external__nodes__get_int(&self.blob) as *mut Int).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_irange_mut(&mut self) -> Option<&mut Irange> {
unsafe { (lib_ruby_parser__external__nodes__get_irange(&self.blob) as *mut Irange).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_ivar_mut(&mut self) -> Option<&mut Ivar> {
unsafe { (lib_ruby_parser__external__nodes__get_ivar(&self.blob) as *mut Ivar).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_ivasgn_mut(&mut self) -> Option<&mut Ivasgn> {
unsafe { (lib_ruby_parser__external__nodes__get_ivasgn(&self.blob) as *mut Ivasgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_kwarg_mut(&mut self) -> Option<&mut Kwarg> {
unsafe { (lib_ruby_parser__external__nodes__get_kwarg(&self.blob) as *mut Kwarg).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_kwargs_mut(&mut self) -> Option<&mut Kwargs> {
unsafe { (lib_ruby_parser__external__nodes__get_kwargs(&self.blob) as *mut Kwargs).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_kw_begin_mut(&mut self) -> Option<&mut KwBegin> {
unsafe { (lib_ruby_parser__external__nodes__get_kw_begin(&self.blob) as *mut KwBegin).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_kwnilarg_mut(&mut self) -> Option<&mut Kwnilarg> {
unsafe { (lib_ruby_parser__external__nodes__get_kwnilarg(&self.blob) as *mut Kwnilarg).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_kwoptarg_mut(&mut self) -> Option<&mut Kwoptarg> {
unsafe { (lib_ruby_parser__external__nodes__get_kwoptarg(&self.blob) as *mut Kwoptarg).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_kwrestarg_mut(&mut self) -> Option<&mut Kwrestarg> {
unsafe { (lib_ruby_parser__external__nodes__get_kwrestarg(&self.blob) as *mut Kwrestarg).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_kwsplat_mut(&mut self) -> Option<&mut Kwsplat> {
unsafe { (lib_ruby_parser__external__nodes__get_kwsplat(&self.blob) as *mut Kwsplat).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_lambda_mut(&mut self) -> Option<&mut Lambda> {
unsafe { (lib_ruby_parser__external__nodes__get_lambda(&self.blob) as *mut Lambda).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_line_mut(&mut self) -> Option<&mut Line> {
unsafe { (lib_ruby_parser__external__nodes__get_line(&self.blob) as *mut Line).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_lvar_mut(&mut self) -> Option<&mut Lvar> {
unsafe { (lib_ruby_parser__external__nodes__get_lvar(&self.blob) as *mut Lvar).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_lvasgn_mut(&mut self) -> Option<&mut Lvasgn> {
unsafe { (lib_ruby_parser__external__nodes__get_lvasgn(&self.blob) as *mut Lvasgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_masgn_mut(&mut self) -> Option<&mut Masgn> {
unsafe { (lib_ruby_parser__external__nodes__get_masgn(&self.blob) as *mut Masgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_match_alt_mut(&mut self) -> Option<&mut MatchAlt> {
unsafe { (lib_ruby_parser__external__nodes__get_match_alt(&self.blob) as *mut MatchAlt).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_match_as_mut(&mut self) -> Option<&mut MatchAs> {
unsafe { (lib_ruby_parser__external__nodes__get_match_as(&self.blob) as *mut MatchAs).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_match_current_line_mut(&mut self) -> Option<&mut MatchCurrentLine> {
unsafe { (lib_ruby_parser__external__nodes__get_match_current_line(&self.blob) as *mut MatchCurrentLine).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_match_nil_pattern_mut(&mut self) -> Option<&mut MatchNilPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_match_nil_pattern(&self.blob) as *mut MatchNilPattern).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_match_pattern_mut(&mut self) -> Option<&mut MatchPattern> {
unsafe { (lib_ruby_parser__external__nodes__get_match_pattern(&self.blob) as *mut MatchPattern).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_match_pattern_p_mut(&mut self) -> Option<&mut MatchPatternP> {
unsafe { (lib_ruby_parser__external__nodes__get_match_pattern_p(&self.blob) as *mut MatchPatternP).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_match_rest_mut(&mut self) -> Option<&mut MatchRest> {
unsafe { (lib_ruby_parser__external__nodes__get_match_rest(&self.blob) as *mut MatchRest).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_match_var_mut(&mut self) -> Option<&mut MatchVar> {
unsafe { (lib_ruby_parser__external__nodes__get_match_var(&self.blob) as *mut MatchVar).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_match_with_lvasgn_mut(&mut self) -> Option<&mut MatchWithLvasgn> {
unsafe { (lib_ruby_parser__external__nodes__get_match_with_lvasgn(&self.blob) as *mut MatchWithLvasgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_mlhs_mut(&mut self) -> Option<&mut Mlhs> {
unsafe { (lib_ruby_parser__external__nodes__get_mlhs(&self.blob) as *mut Mlhs).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_module_mut(&mut self) -> Option<&mut Module> {
unsafe { (lib_ruby_parser__external__nodes__get_module(&self.blob) as *mut Module).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_next_mut(&mut self) -> Option<&mut Next> {
unsafe { (lib_ruby_parser__external__nodes__get_next(&self.blob) as *mut Next).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_nil_mut(&mut self) -> Option<&mut Nil> {
unsafe { (lib_ruby_parser__external__nodes__get_nil(&self.blob) as *mut Nil).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_nth_ref_mut(&mut self) -> Option<&mut NthRef> {
unsafe { (lib_ruby_parser__external__nodes__get_nth_ref(&self.blob) as *mut NthRef).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_numblock_mut(&mut self) -> Option<&mut Numblock> {
unsafe { (lib_ruby_parser__external__nodes__get_numblock(&self.blob) as *mut Numblock).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_op_asgn_mut(&mut self) -> Option<&mut OpAsgn> {
unsafe { (lib_ruby_parser__external__nodes__get_op_asgn(&self.blob) as *mut OpAsgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_optarg_mut(&mut self) -> Option<&mut Optarg> {
unsafe { (lib_ruby_parser__external__nodes__get_optarg(&self.blob) as *mut Optarg).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_or_mut(&mut self) -> Option<&mut Or> {
unsafe { (lib_ruby_parser__external__nodes__get_or(&self.blob) as *mut Or).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_or_asgn_mut(&mut self) -> Option<&mut OrAsgn> {
unsafe { (lib_ruby_parser__external__nodes__get_or_asgn(&self.blob) as *mut OrAsgn).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_pair_mut(&mut self) -> Option<&mut Pair> {
unsafe { (lib_ruby_parser__external__nodes__get_pair(&self.blob) as *mut Pair).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_pin_mut(&mut self) -> Option<&mut Pin> {
unsafe { (lib_ruby_parser__external__nodes__get_pin(&self.blob) as *mut Pin).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_postexe_mut(&mut self) -> Option<&mut Postexe> {
unsafe { (lib_ruby_parser__external__nodes__get_postexe(&self.blob) as *mut Postexe).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_preexe_mut(&mut self) -> Option<&mut Preexe> {
unsafe { (lib_ruby_parser__external__nodes__get_preexe(&self.blob) as *mut Preexe).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_procarg0_mut(&mut self) -> Option<&mut Procarg0> {
unsafe { (lib_ruby_parser__external__nodes__get_procarg0(&self.blob) as *mut Procarg0).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_rational_mut(&mut self) -> Option<&mut Rational> {
unsafe { (lib_ruby_parser__external__nodes__get_rational(&self.blob) as *mut Rational).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_redo_mut(&mut self) -> Option<&mut Redo> {
unsafe { (lib_ruby_parser__external__nodes__get_redo(&self.blob) as *mut Redo).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_regexp_mut(&mut self) -> Option<&mut Regexp> {
unsafe { (lib_ruby_parser__external__nodes__get_regexp(&self.blob) as *mut Regexp).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_reg_opt_mut(&mut self) -> Option<&mut RegOpt> {
unsafe { (lib_ruby_parser__external__nodes__get_reg_opt(&self.blob) as *mut RegOpt).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_rescue_mut(&mut self) -> Option<&mut Rescue> {
unsafe { (lib_ruby_parser__external__nodes__get_rescue(&self.blob) as *mut Rescue).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_rescue_body_mut(&mut self) -> Option<&mut RescueBody> {
unsafe { (lib_ruby_parser__external__nodes__get_rescue_body(&self.blob) as *mut RescueBody).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_restarg_mut(&mut self) -> Option<&mut Restarg> {
unsafe { (lib_ruby_parser__external__nodes__get_restarg(&self.blob) as *mut Restarg).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_retry_mut(&mut self) -> Option<&mut Retry> {
unsafe { (lib_ruby_parser__external__nodes__get_retry(&self.blob) as *mut Retry).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_return_mut(&mut self) -> Option<&mut Return> {
unsafe { (lib_ruby_parser__external__nodes__get_return(&self.blob) as *mut Return).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_s_class_mut(&mut self) -> Option<&mut SClass> {
unsafe { (lib_ruby_parser__external__nodes__get_s_class(&self.blob) as *mut SClass).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_self__mut(&mut self) -> Option<&mut Self_> {
unsafe { (lib_ruby_parser__external__nodes__get_self_(&self.blob) as *mut Self_).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_send_mut(&mut self) -> Option<&mut Send> {
unsafe { (lib_ruby_parser__external__nodes__get_send(&self.blob) as *mut Send).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_shadowarg_mut(&mut self) -> Option<&mut Shadowarg> {
unsafe { (lib_ruby_parser__external__nodes__get_shadowarg(&self.blob) as *mut Shadowarg).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_splat_mut(&mut self) -> Option<&mut Splat> {
unsafe { (lib_ruby_parser__external__nodes__get_splat(&self.blob) as *mut Splat).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_str_mut(&mut self) -> Option<&mut Str> {
unsafe { (lib_ruby_parser__external__nodes__get_str(&self.blob) as *mut Str).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_super_mut(&mut self) -> Option<&mut Super> {
unsafe { (lib_ruby_parser__external__nodes__get_super(&self.blob) as *mut Super).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_sym_mut(&mut self) -> Option<&mut Sym> {
unsafe { (lib_ruby_parser__external__nodes__get_sym(&self.blob) as *mut Sym).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_true_mut(&mut self) -> Option<&mut True> {
unsafe { (lib_ruby_parser__external__nodes__get_true(&self.blob) as *mut True).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_undef_mut(&mut self) -> Option<&mut Undef> {
unsafe { (lib_ruby_parser__external__nodes__get_undef(&self.blob) as *mut Undef).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_unless_guard_mut(&mut self) -> Option<&mut UnlessGuard> {
unsafe { (lib_ruby_parser__external__nodes__get_unless_guard(&self.blob) as *mut UnlessGuard).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_until_mut(&mut self) -> Option<&mut Until> {
unsafe { (lib_ruby_parser__external__nodes__get_until(&self.blob) as *mut Until).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_until_post_mut(&mut self) -> Option<&mut UntilPost> {
unsafe { (lib_ruby_parser__external__nodes__get_until_post(&self.blob) as *mut UntilPost).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_when_mut(&mut self) -> Option<&mut When> {
unsafe { (lib_ruby_parser__external__nodes__get_when(&self.blob) as *mut When).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_while_mut(&mut self) -> Option<&mut While> {
unsafe { (lib_ruby_parser__external__nodes__get_while(&self.blob) as *mut While).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_while_post_mut(&mut self) -> Option<&mut WhilePost> {
unsafe { (lib_ruby_parser__external__nodes__get_while_post(&self.blob) as *mut WhilePost).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_x_heredoc_mut(&mut self) -> Option<&mut XHeredoc> {
unsafe { (lib_ruby_parser__external__nodes__get_x_heredoc(&self.blob) as *mut XHeredoc).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_xstr_mut(&mut self) -> Option<&mut Xstr> {
unsafe { (lib_ruby_parser__external__nodes__get_xstr(&self.blob) as *mut Xstr).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_yield_mut(&mut self) -> Option<&mut Yield> {
unsafe { (lib_ruby_parser__external__nodes__get_yield(&self.blob) as *mut Yield).as_mut() }
}
#[allow(non_snake_case)]
pub fn as_z_super_mut(&mut self) -> Option<&mut ZSuper> {
unsafe { (lib_ruby_parser__external__nodes__get_z_super(&self.blob) as *mut ZSuper).as_mut() }
}
pub fn into_alias(self) -> Alias {
let blob = unsafe { lib_ruby_parser__external__nodes__into_alias(self.into_blob()) };
Alias { blob }
}
pub fn into_and(self) -> And {
let blob = unsafe { lib_ruby_parser__external__nodes__into_and(self.into_blob()) };
And { blob }
}
pub fn into_and_asgn(self) -> AndAsgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_and_asgn(self.into_blob()) };
AndAsgn { blob }
}
pub fn into_arg(self) -> Arg {
let blob = unsafe { lib_ruby_parser__external__nodes__into_arg(self.into_blob()) };
Arg { blob }
}
pub fn into_args(self) -> Args {
let blob = unsafe { lib_ruby_parser__external__nodes__into_args(self.into_blob()) };
Args { blob }
}
pub fn into_array(self) -> Array {
let blob = unsafe { lib_ruby_parser__external__nodes__into_array(self.into_blob()) };
Array { blob }
}
pub fn into_array_pattern(self) -> ArrayPattern {
let blob = unsafe { lib_ruby_parser__external__nodes__into_array_pattern(self.into_blob()) };
ArrayPattern { blob }
}
pub fn into_array_pattern_with_tail(self) -> ArrayPatternWithTail {
let blob = unsafe { lib_ruby_parser__external__nodes__into_array_pattern_with_tail(self.into_blob()) };
ArrayPatternWithTail { blob }
}
pub fn into_back_ref(self) -> BackRef {
let blob = unsafe { lib_ruby_parser__external__nodes__into_back_ref(self.into_blob()) };
BackRef { blob }
}
pub fn into_begin(self) -> Begin {
let blob = unsafe { lib_ruby_parser__external__nodes__into_begin(self.into_blob()) };
Begin { blob }
}
pub fn into_block(self) -> Block {
let blob = unsafe { lib_ruby_parser__external__nodes__into_block(self.into_blob()) };
Block { blob }
}
pub fn into_blockarg(self) -> Blockarg {
let blob = unsafe { lib_ruby_parser__external__nodes__into_blockarg(self.into_blob()) };
Blockarg { blob }
}
pub fn into_block_pass(self) -> BlockPass {
let blob = unsafe { lib_ruby_parser__external__nodes__into_block_pass(self.into_blob()) };
BlockPass { blob }
}
pub fn into_break(self) -> Break {
let blob = unsafe { lib_ruby_parser__external__nodes__into_break(self.into_blob()) };
Break { blob }
}
pub fn into_case(self) -> Case {
let blob = unsafe { lib_ruby_parser__external__nodes__into_case(self.into_blob()) };
Case { blob }
}
pub fn into_case_match(self) -> CaseMatch {
let blob = unsafe { lib_ruby_parser__external__nodes__into_case_match(self.into_blob()) };
CaseMatch { blob }
}
pub fn into_casgn(self) -> Casgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_casgn(self.into_blob()) };
Casgn { blob }
}
pub fn into_cbase(self) -> Cbase {
let blob = unsafe { lib_ruby_parser__external__nodes__into_cbase(self.into_blob()) };
Cbase { blob }
}
pub fn into_class(self) -> Class {
let blob = unsafe { lib_ruby_parser__external__nodes__into_class(self.into_blob()) };
Class { blob }
}
pub fn into_complex(self) -> Complex {
let blob = unsafe { lib_ruby_parser__external__nodes__into_complex(self.into_blob()) };
Complex { blob }
}
pub fn into_const(self) -> Const {
let blob = unsafe { lib_ruby_parser__external__nodes__into_const(self.into_blob()) };
Const { blob }
}
pub fn into_const_pattern(self) -> ConstPattern {
let blob = unsafe { lib_ruby_parser__external__nodes__into_const_pattern(self.into_blob()) };
ConstPattern { blob }
}
pub fn into_c_send(self) -> CSend {
let blob = unsafe { lib_ruby_parser__external__nodes__into_c_send(self.into_blob()) };
CSend { blob }
}
pub fn into_cvar(self) -> Cvar {
let blob = unsafe { lib_ruby_parser__external__nodes__into_cvar(self.into_blob()) };
Cvar { blob }
}
pub fn into_cvasgn(self) -> Cvasgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_cvasgn(self.into_blob()) };
Cvasgn { blob }
}
pub fn into_def(self) -> Def {
let blob = unsafe { lib_ruby_parser__external__nodes__into_def(self.into_blob()) };
Def { blob }
}
pub fn into_defined(self) -> Defined {
let blob = unsafe { lib_ruby_parser__external__nodes__into_defined(self.into_blob()) };
Defined { blob }
}
pub fn into_defs(self) -> Defs {
let blob = unsafe { lib_ruby_parser__external__nodes__into_defs(self.into_blob()) };
Defs { blob }
}
pub fn into_dstr(self) -> Dstr {
let blob = unsafe { lib_ruby_parser__external__nodes__into_dstr(self.into_blob()) };
Dstr { blob }
}
pub fn into_dsym(self) -> Dsym {
let blob = unsafe { lib_ruby_parser__external__nodes__into_dsym(self.into_blob()) };
Dsym { blob }
}
pub fn into_e_flip_flop(self) -> EFlipFlop {
let blob = unsafe { lib_ruby_parser__external__nodes__into_e_flip_flop(self.into_blob()) };
EFlipFlop { blob }
}
pub fn into_empty_else(self) -> EmptyElse {
let blob = unsafe { lib_ruby_parser__external__nodes__into_empty_else(self.into_blob()) };
EmptyElse { blob }
}
pub fn into_encoding(self) -> Encoding {
let blob = unsafe { lib_ruby_parser__external__nodes__into_encoding(self.into_blob()) };
Encoding { blob }
}
pub fn into_ensure(self) -> Ensure {
let blob = unsafe { lib_ruby_parser__external__nodes__into_ensure(self.into_blob()) };
Ensure { blob }
}
pub fn into_erange(self) -> Erange {
let blob = unsafe { lib_ruby_parser__external__nodes__into_erange(self.into_blob()) };
Erange { blob }
}
pub fn into_false(self) -> False {
let blob = unsafe { lib_ruby_parser__external__nodes__into_false(self.into_blob()) };
False { blob }
}
pub fn into_file(self) -> File {
let blob = unsafe { lib_ruby_parser__external__nodes__into_file(self.into_blob()) };
File { blob }
}
pub fn into_find_pattern(self) -> FindPattern {
let blob = unsafe { lib_ruby_parser__external__nodes__into_find_pattern(self.into_blob()) };
FindPattern { blob }
}
pub fn into_float(self) -> Float {
let blob = unsafe { lib_ruby_parser__external__nodes__into_float(self.into_blob()) };
Float { blob }
}
pub fn into_for(self) -> For {
let blob = unsafe { lib_ruby_parser__external__nodes__into_for(self.into_blob()) };
For { blob }
}
pub fn into_forward_arg(self) -> ForwardArg {
let blob = unsafe { lib_ruby_parser__external__nodes__into_forward_arg(self.into_blob()) };
ForwardArg { blob }
}
pub fn into_forwarded_args(self) -> ForwardedArgs {
let blob = unsafe { lib_ruby_parser__external__nodes__into_forwarded_args(self.into_blob()) };
ForwardedArgs { blob }
}
pub fn into_gvar(self) -> Gvar {
let blob = unsafe { lib_ruby_parser__external__nodes__into_gvar(self.into_blob()) };
Gvar { blob }
}
pub fn into_gvasgn(self) -> Gvasgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_gvasgn(self.into_blob()) };
Gvasgn { blob }
}
pub fn into_hash(self) -> Hash {
let blob = unsafe { lib_ruby_parser__external__nodes__into_hash(self.into_blob()) };
Hash { blob }
}
pub fn into_hash_pattern(self) -> HashPattern {
let blob = unsafe { lib_ruby_parser__external__nodes__into_hash_pattern(self.into_blob()) };
HashPattern { blob }
}
pub fn into_heredoc(self) -> Heredoc {
let blob = unsafe { lib_ruby_parser__external__nodes__into_heredoc(self.into_blob()) };
Heredoc { blob }
}
pub fn into_if(self) -> If {
let blob = unsafe { lib_ruby_parser__external__nodes__into_if(self.into_blob()) };
If { blob }
}
pub fn into_if_guard(self) -> IfGuard {
let blob = unsafe { lib_ruby_parser__external__nodes__into_if_guard(self.into_blob()) };
IfGuard { blob }
}
pub fn into_i_flip_flop(self) -> IFlipFlop {
let blob = unsafe { lib_ruby_parser__external__nodes__into_i_flip_flop(self.into_blob()) };
IFlipFlop { blob }
}
pub fn into_if_mod(self) -> IfMod {
let blob = unsafe { lib_ruby_parser__external__nodes__into_if_mod(self.into_blob()) };
IfMod { blob }
}
pub fn into_if_ternary(self) -> IfTernary {
let blob = unsafe { lib_ruby_parser__external__nodes__into_if_ternary(self.into_blob()) };
IfTernary { blob }
}
pub fn into_index(self) -> Index {
let blob = unsafe { lib_ruby_parser__external__nodes__into_index(self.into_blob()) };
Index { blob }
}
pub fn into_index_asgn(self) -> IndexAsgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_index_asgn(self.into_blob()) };
IndexAsgn { blob }
}
pub fn into_in_pattern(self) -> InPattern {
let blob = unsafe { lib_ruby_parser__external__nodes__into_in_pattern(self.into_blob()) };
InPattern { blob }
}
pub fn into_int(self) -> Int {
let blob = unsafe { lib_ruby_parser__external__nodes__into_int(self.into_blob()) };
Int { blob }
}
pub fn into_irange(self) -> Irange {
let blob = unsafe { lib_ruby_parser__external__nodes__into_irange(self.into_blob()) };
Irange { blob }
}
pub fn into_ivar(self) -> Ivar {
let blob = unsafe { lib_ruby_parser__external__nodes__into_ivar(self.into_blob()) };
Ivar { blob }
}
pub fn into_ivasgn(self) -> Ivasgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_ivasgn(self.into_blob()) };
Ivasgn { blob }
}
pub fn into_kwarg(self) -> Kwarg {
let blob = unsafe { lib_ruby_parser__external__nodes__into_kwarg(self.into_blob()) };
Kwarg { blob }
}
pub fn into_kwargs(self) -> Kwargs {
let blob = unsafe { lib_ruby_parser__external__nodes__into_kwargs(self.into_blob()) };
Kwargs { blob }
}
pub fn into_kw_begin(self) -> KwBegin {
let blob = unsafe { lib_ruby_parser__external__nodes__into_kw_begin(self.into_blob()) };
KwBegin { blob }
}
pub fn into_kwnilarg(self) -> Kwnilarg {
let blob = unsafe { lib_ruby_parser__external__nodes__into_kwnilarg(self.into_blob()) };
Kwnilarg { blob }
}
pub fn into_kwoptarg(self) -> Kwoptarg {
let blob = unsafe { lib_ruby_parser__external__nodes__into_kwoptarg(self.into_blob()) };
Kwoptarg { blob }
}
pub fn into_kwrestarg(self) -> Kwrestarg {
let blob = unsafe { lib_ruby_parser__external__nodes__into_kwrestarg(self.into_blob()) };
Kwrestarg { blob }
}
pub fn into_kwsplat(self) -> Kwsplat {
let blob = unsafe { lib_ruby_parser__external__nodes__into_kwsplat(self.into_blob()) };
Kwsplat { blob }
}
pub fn into_lambda(self) -> Lambda {
let blob = unsafe { lib_ruby_parser__external__nodes__into_lambda(self.into_blob()) };
Lambda { blob }
}
pub fn into_line(self) -> Line {
let blob = unsafe { lib_ruby_parser__external__nodes__into_line(self.into_blob()) };
Line { blob }
}
pub fn into_lvar(self) -> Lvar {
let blob = unsafe { lib_ruby_parser__external__nodes__into_lvar(self.into_blob()) };
Lvar { blob }
}
pub fn into_lvasgn(self) -> Lvasgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_lvasgn(self.into_blob()) };
Lvasgn { blob }
}
pub fn into_masgn(self) -> Masgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_masgn(self.into_blob()) };
Masgn { blob }
}
pub fn into_match_alt(self) -> MatchAlt {
let blob = unsafe { lib_ruby_parser__external__nodes__into_match_alt(self.into_blob()) };
MatchAlt { blob }
}
pub fn into_match_as(self) -> MatchAs {
let blob = unsafe { lib_ruby_parser__external__nodes__into_match_as(self.into_blob()) };
MatchAs { blob }
}
pub fn into_match_current_line(self) -> MatchCurrentLine {
let blob = unsafe { lib_ruby_parser__external__nodes__into_match_current_line(self.into_blob()) };
MatchCurrentLine { blob }
}
pub fn into_match_nil_pattern(self) -> MatchNilPattern {
let blob = unsafe { lib_ruby_parser__external__nodes__into_match_nil_pattern(self.into_blob()) };
MatchNilPattern { blob }
}
pub fn into_match_pattern(self) -> MatchPattern {
let blob = unsafe { lib_ruby_parser__external__nodes__into_match_pattern(self.into_blob()) };
MatchPattern { blob }
}
pub fn into_match_pattern_p(self) -> MatchPatternP {
let blob = unsafe { lib_ruby_parser__external__nodes__into_match_pattern_p(self.into_blob()) };
MatchPatternP { blob }
}
pub fn into_match_rest(self) -> MatchRest {
let blob = unsafe { lib_ruby_parser__external__nodes__into_match_rest(self.into_blob()) };
MatchRest { blob }
}
pub fn into_match_var(self) -> MatchVar {
let blob = unsafe { lib_ruby_parser__external__nodes__into_match_var(self.into_blob()) };
MatchVar { blob }
}
pub fn into_match_with_lvasgn(self) -> MatchWithLvasgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_match_with_lvasgn(self.into_blob()) };
MatchWithLvasgn { blob }
}
pub fn into_mlhs(self) -> Mlhs {
let blob = unsafe { lib_ruby_parser__external__nodes__into_mlhs(self.into_blob()) };
Mlhs { blob }
}
pub fn into_module(self) -> Module {
let blob = unsafe { lib_ruby_parser__external__nodes__into_module(self.into_blob()) };
Module { blob }
}
pub fn into_next(self) -> Next {
let blob = unsafe { lib_ruby_parser__external__nodes__into_next(self.into_blob()) };
Next { blob }
}
pub fn into_nil(self) -> Nil {
let blob = unsafe { lib_ruby_parser__external__nodes__into_nil(self.into_blob()) };
Nil { blob }
}
pub fn into_nth_ref(self) -> NthRef {
let blob = unsafe { lib_ruby_parser__external__nodes__into_nth_ref(self.into_blob()) };
NthRef { blob }
}
pub fn into_numblock(self) -> Numblock {
let blob = unsafe { lib_ruby_parser__external__nodes__into_numblock(self.into_blob()) };
Numblock { blob }
}
pub fn into_op_asgn(self) -> OpAsgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_op_asgn(self.into_blob()) };
OpAsgn { blob }
}
pub fn into_optarg(self) -> Optarg {
let blob = unsafe { lib_ruby_parser__external__nodes__into_optarg(self.into_blob()) };
Optarg { blob }
}
pub fn into_or(self) -> Or {
let blob = unsafe { lib_ruby_parser__external__nodes__into_or(self.into_blob()) };
Or { blob }
}
pub fn into_or_asgn(self) -> OrAsgn {
let blob = unsafe { lib_ruby_parser__external__nodes__into_or_asgn(self.into_blob()) };
OrAsgn { blob }
}
pub fn into_pair(self) -> Pair {
let blob = unsafe { lib_ruby_parser__external__nodes__into_pair(self.into_blob()) };
Pair { blob }
}
pub fn into_pin(self) -> Pin {
let blob = unsafe { lib_ruby_parser__external__nodes__into_pin(self.into_blob()) };
Pin { blob }
}
pub fn into_postexe(self) -> Postexe {
let blob = unsafe { lib_ruby_parser__external__nodes__into_postexe(self.into_blob()) };
Postexe { blob }
}
pub fn into_preexe(self) -> Preexe {
let blob = unsafe { lib_ruby_parser__external__nodes__into_preexe(self.into_blob()) };
Preexe { blob }
}
pub fn into_procarg0(self) -> Procarg0 {
let blob = unsafe { lib_ruby_parser__external__nodes__into_procarg0(self.into_blob()) };
Procarg0 { blob }
}
pub fn into_rational(self) -> Rational {
let blob = unsafe { lib_ruby_parser__external__nodes__into_rational(self.into_blob()) };
Rational { blob }
}
pub fn into_redo(self) -> Redo {
let blob = unsafe { lib_ruby_parser__external__nodes__into_redo(self.into_blob()) };
Redo { blob }
}
pub fn into_regexp(self) -> Regexp {
let blob = unsafe { lib_ruby_parser__external__nodes__into_regexp(self.into_blob()) };
Regexp { blob }
}
pub fn into_reg_opt(self) -> RegOpt {
let blob = unsafe { lib_ruby_parser__external__nodes__into_reg_opt(self.into_blob()) };
RegOpt { blob }
}
pub fn into_rescue(self) -> Rescue {
let blob = unsafe { lib_ruby_parser__external__nodes__into_rescue(self.into_blob()) };
Rescue { blob }
}
pub fn into_rescue_body(self) -> RescueBody {
let blob = unsafe { lib_ruby_parser__external__nodes__into_rescue_body(self.into_blob()) };
RescueBody { blob }
}
pub fn into_restarg(self) -> Restarg {
let blob = unsafe { lib_ruby_parser__external__nodes__into_restarg(self.into_blob()) };
Restarg { blob }
}
pub fn into_retry(self) -> Retry {
let blob = unsafe { lib_ruby_parser__external__nodes__into_retry(self.into_blob()) };
Retry { blob }
}
pub fn into_return(self) -> Return {
let blob = unsafe { lib_ruby_parser__external__nodes__into_return(self.into_blob()) };
Return { blob }
}
pub fn into_s_class(self) -> SClass {
let blob = unsafe { lib_ruby_parser__external__nodes__into_s_class(self.into_blob()) };
SClass { blob }
}
pub fn into_self_(self) -> Self_ {
let blob = unsafe { lib_ruby_parser__external__nodes__into_self_(self.into_blob()) };
Self_ { blob }
}
pub fn into_send(self) -> Send {
let blob = unsafe { lib_ruby_parser__external__nodes__into_send(self.into_blob()) };
Send { blob }
}
pub fn into_shadowarg(self) -> Shadowarg {
let blob = unsafe { lib_ruby_parser__external__nodes__into_shadowarg(self.into_blob()) };
Shadowarg { blob }
}
pub fn into_splat(self) -> Splat {
let blob = unsafe { lib_ruby_parser__external__nodes__into_splat(self.into_blob()) };
Splat { blob }
}
pub fn into_str(self) -> Str {
let blob = unsafe { lib_ruby_parser__external__nodes__into_str(self.into_blob()) };
Str { blob }
}
pub fn into_super(self) -> Super {
let blob = unsafe { lib_ruby_parser__external__nodes__into_super(self.into_blob()) };
Super { blob }
}
pub fn into_sym(self) -> Sym {
let blob = unsafe { lib_ruby_parser__external__nodes__into_sym(self.into_blob()) };
Sym { blob }
}
pub fn into_true(self) -> True {
let blob = unsafe { lib_ruby_parser__external__nodes__into_true(self.into_blob()) };
True { blob }
}
pub fn into_undef(self) -> Undef {
let blob = unsafe { lib_ruby_parser__external__nodes__into_undef(self.into_blob()) };
Undef { blob }
}
pub fn into_unless_guard(self) -> UnlessGuard {
let blob = unsafe { lib_ruby_parser__external__nodes__into_unless_guard(self.into_blob()) };
UnlessGuard { blob }
}
pub fn into_until(self) -> Until {
let blob = unsafe { lib_ruby_parser__external__nodes__into_until(self.into_blob()) };
Until { blob }
}
pub fn into_until_post(self) -> UntilPost {
let blob = unsafe { lib_ruby_parser__external__nodes__into_until_post(self.into_blob()) };
UntilPost { blob }
}
pub fn into_when(self) -> When {
let blob = unsafe { lib_ruby_parser__external__nodes__into_when(self.into_blob()) };
When { blob }
}
pub fn into_while(self) -> While {
let blob = unsafe { lib_ruby_parser__external__nodes__into_while(self.into_blob()) };
While { blob }
}
pub fn into_while_post(self) -> WhilePost {
let blob = unsafe { lib_ruby_parser__external__nodes__into_while_post(self.into_blob()) };
WhilePost { blob }
}
pub fn into_x_heredoc(self) -> XHeredoc {
let blob = unsafe { lib_ruby_parser__external__nodes__into_x_heredoc(self.into_blob()) };
XHeredoc { blob }
}
pub fn into_xstr(self) -> Xstr {
let blob = unsafe { lib_ruby_parser__external__nodes__into_xstr(self.into_blob()) };
Xstr { blob }
}
pub fn into_yield(self) -> Yield {
let blob = unsafe { lib_ruby_parser__external__nodes__into_yield(self.into_blob()) };
Yield { blob }
}
pub fn into_z_super(self) -> ZSuper {
let blob = unsafe { lib_ruby_parser__external__nodes__into_z_super(self.into_blob()) };
ZSuper { blob }
}
}
extern "C"
{
fn lib_ruby_parser__external__nodes__new_alias(to: Blob<Ptr<Node>>, from: Blob<Ptr<Node>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_alias(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_alias(blob_ptr: *const Blob<Node>) -> *mut Blob<Alias>;
fn lib_ruby_parser__external__nodes__into_alias(blob: Blob<Node>) -> Blob<Alias>;
fn lib_ruby_parser__external__nodes__new_and(lhs: Blob<Ptr<Node>>, rhs: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_and(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_and(blob_ptr: *const Blob<Node>) -> *mut Blob<And>;
fn lib_ruby_parser__external__nodes__into_and(blob: Blob<Node>) -> Blob<And>;
fn lib_ruby_parser__external__nodes__new_and_asgn(recv: Blob<Ptr<Node>>, value: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_and_asgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_and_asgn(blob_ptr: *const Blob<Node>) -> *mut Blob<AndAsgn>;
fn lib_ruby_parser__external__nodes__into_and_asgn(blob: Blob<Node>) -> Blob<AndAsgn>;
fn lib_ruby_parser__external__nodes__new_arg(name: Blob<StringPtr>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_arg(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_arg(blob_ptr: *const Blob<Node>) -> *mut Blob<Arg>;
fn lib_ruby_parser__external__nodes__into_arg(blob: Blob<Node>) -> Blob<Arg>;
fn lib_ruby_parser__external__nodes__new_args(args: Blob<List<Node>>, expression_l: Blob<Loc>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_args(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_args(blob_ptr: *const Blob<Node>) -> *mut Blob<Args>;
fn lib_ruby_parser__external__nodes__into_args(blob: Blob<Node>) -> Blob<Args>;
fn lib_ruby_parser__external__nodes__new_array(elements: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_array(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_array(blob_ptr: *const Blob<Node>) -> *mut Blob<Array>;
fn lib_ruby_parser__external__nodes__into_array(blob: Blob<Node>) -> Blob<Array>;
fn lib_ruby_parser__external__nodes__new_array_pattern(elements: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_array_pattern(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_array_pattern(blob_ptr: *const Blob<Node>) -> *mut Blob<ArrayPattern>;
fn lib_ruby_parser__external__nodes__into_array_pattern(blob: Blob<Node>) -> Blob<ArrayPattern>;
fn lib_ruby_parser__external__nodes__new_array_pattern_with_tail(elements: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_array_pattern_with_tail(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_array_pattern_with_tail(blob_ptr: *const Blob<Node>) -> *mut Blob<ArrayPatternWithTail>;
fn lib_ruby_parser__external__nodes__into_array_pattern_with_tail(blob: Blob<Node>) -> Blob<ArrayPatternWithTail>;
fn lib_ruby_parser__external__nodes__new_back_ref(name: Blob<StringPtr>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_back_ref(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_back_ref(blob_ptr: *const Blob<Node>) -> *mut Blob<BackRef>;
fn lib_ruby_parser__external__nodes__into_back_ref(blob: Blob<Node>) -> Blob<BackRef>;
fn lib_ruby_parser__external__nodes__new_begin(statements: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_begin(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_begin(blob_ptr: *const Blob<Node>) -> *mut Blob<Begin>;
fn lib_ruby_parser__external__nodes__into_begin(blob: Blob<Node>) -> Blob<Begin>;
fn lib_ruby_parser__external__nodes__new_block(call: Blob<Ptr<Node>>, args: Blob<Maybe<Ptr<Node>>>, body: Blob<Maybe<Ptr<Node>>>, begin_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_block(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_block(blob_ptr: *const Blob<Node>) -> *mut Blob<Block>;
fn lib_ruby_parser__external__nodes__into_block(blob: Blob<Node>) -> Blob<Block>;
fn lib_ruby_parser__external__nodes__new_blockarg(name: Blob<StringPtr>, operator_l: Blob<Loc>, name_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_blockarg(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_blockarg(blob_ptr: *const Blob<Node>) -> *mut Blob<Blockarg>;
fn lib_ruby_parser__external__nodes__into_blockarg(blob: Blob<Node>) -> Blob<Blockarg>;
fn lib_ruby_parser__external__nodes__new_block_pass(value: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_block_pass(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_block_pass(blob_ptr: *const Blob<Node>) -> *mut Blob<BlockPass>;
fn lib_ruby_parser__external__nodes__into_block_pass(blob: Blob<Node>) -> Blob<BlockPass>;
fn lib_ruby_parser__external__nodes__new_break(args: Blob<List<Node>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_break(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_break(blob_ptr: *const Blob<Node>) -> *mut Blob<Break>;
fn lib_ruby_parser__external__nodes__into_break(blob: Blob<Node>) -> Blob<Break>;
fn lib_ruby_parser__external__nodes__new_case(expr: Blob<Maybe<Ptr<Node>>>, when_bodies: Blob<List<Node>>, else_body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, else_l: Blob<Maybe<Loc>>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_case(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_case(blob_ptr: *const Blob<Node>) -> *mut Blob<Case>;
fn lib_ruby_parser__external__nodes__into_case(blob: Blob<Node>) -> Blob<Case>;
fn lib_ruby_parser__external__nodes__new_case_match(expr: Blob<Ptr<Node>>, in_bodies: Blob<List<Node>>, else_body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, else_l: Blob<Maybe<Loc>>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_case_match(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_case_match(blob_ptr: *const Blob<Node>) -> *mut Blob<CaseMatch>;
fn lib_ruby_parser__external__nodes__into_case_match(blob: Blob<Node>) -> Blob<CaseMatch>;
fn lib_ruby_parser__external__nodes__new_casgn(scope: Blob<Maybe<Ptr<Node>>>, name: Blob<StringPtr>, value: Blob<Maybe<Ptr<Node>>>, double_colon_l: Blob<Maybe<Loc>>, name_l: Blob<Loc>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_casgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_casgn(blob_ptr: *const Blob<Node>) -> *mut Blob<Casgn>;
fn lib_ruby_parser__external__nodes__into_casgn(blob: Blob<Node>) -> Blob<Casgn>;
fn lib_ruby_parser__external__nodes__new_cbase(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_cbase(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_cbase(blob_ptr: *const Blob<Node>) -> *mut Blob<Cbase>;
fn lib_ruby_parser__external__nodes__into_cbase(blob: Blob<Node>) -> Blob<Cbase>;
fn lib_ruby_parser__external__nodes__new_class(name: Blob<Ptr<Node>>, superclass: Blob<Maybe<Ptr<Node>>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, operator_l: Blob<Maybe<Loc>>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_class(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_class(blob_ptr: *const Blob<Node>) -> *mut Blob<Class>;
fn lib_ruby_parser__external__nodes__into_class(blob: Blob<Node>) -> Blob<Class>;
fn lib_ruby_parser__external__nodes__new_complex(value: Blob<StringPtr>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_complex(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_complex(blob_ptr: *const Blob<Node>) -> *mut Blob<Complex>;
fn lib_ruby_parser__external__nodes__into_complex(blob: Blob<Node>) -> Blob<Complex>;
fn lib_ruby_parser__external__nodes__new_const(scope: Blob<Maybe<Ptr<Node>>>, name: Blob<StringPtr>, double_colon_l: Blob<Maybe<Loc>>, name_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_const(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_const(blob_ptr: *const Blob<Node>) -> *mut Blob<Const>;
fn lib_ruby_parser__external__nodes__into_const(blob: Blob<Node>) -> Blob<Const>;
fn lib_ruby_parser__external__nodes__new_const_pattern(const_: Blob<Ptr<Node>>, pattern: Blob<Ptr<Node>>, begin_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_const_pattern(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_const_pattern(blob_ptr: *const Blob<Node>) -> *mut Blob<ConstPattern>;
fn lib_ruby_parser__external__nodes__into_const_pattern(blob: Blob<Node>) -> Blob<ConstPattern>;
fn lib_ruby_parser__external__nodes__new_c_send(recv: Blob<Ptr<Node>>, method_name: Blob<StringPtr>, args: Blob<List<Node>>, dot_l: Blob<Loc>, selector_l: Blob<Maybe<Loc>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_c_send(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_c_send(blob_ptr: *const Blob<Node>) -> *mut Blob<CSend>;
fn lib_ruby_parser__external__nodes__into_c_send(blob: Blob<Node>) -> Blob<CSend>;
fn lib_ruby_parser__external__nodes__new_cvar(name: Blob<StringPtr>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_cvar(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_cvar(blob_ptr: *const Blob<Node>) -> *mut Blob<Cvar>;
fn lib_ruby_parser__external__nodes__into_cvar(blob: Blob<Node>) -> Blob<Cvar>;
fn lib_ruby_parser__external__nodes__new_cvasgn(name: Blob<StringPtr>, value: Blob<Maybe<Ptr<Node>>>, name_l: Blob<Loc>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_cvasgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_cvasgn(blob_ptr: *const Blob<Node>) -> *mut Blob<Cvasgn>;
fn lib_ruby_parser__external__nodes__into_cvasgn(blob: Blob<Node>) -> Blob<Cvasgn>;
fn lib_ruby_parser__external__nodes__new_def(name: Blob<StringPtr>, args: Blob<Maybe<Ptr<Node>>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, name_l: Blob<Loc>, end_l: Blob<Maybe<Loc>>, assignment_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_def(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_def(blob_ptr: *const Blob<Node>) -> *mut Blob<Def>;
fn lib_ruby_parser__external__nodes__into_def(blob: Blob<Node>) -> Blob<Def>;
fn lib_ruby_parser__external__nodes__new_defined(value: Blob<Ptr<Node>>, keyword_l: Blob<Loc>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_defined(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_defined(blob_ptr: *const Blob<Node>) -> *mut Blob<Defined>;
fn lib_ruby_parser__external__nodes__into_defined(blob: Blob<Node>) -> Blob<Defined>;
fn lib_ruby_parser__external__nodes__new_defs(definee: Blob<Ptr<Node>>, name: Blob<StringPtr>, args: Blob<Maybe<Ptr<Node>>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, operator_l: Blob<Loc>, name_l: Blob<Loc>, assignment_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_defs(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_defs(blob_ptr: *const Blob<Node>) -> *mut Blob<Defs>;
fn lib_ruby_parser__external__nodes__into_defs(blob: Blob<Node>) -> Blob<Defs>;
fn lib_ruby_parser__external__nodes__new_dstr(parts: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_dstr(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_dstr(blob_ptr: *const Blob<Node>) -> *mut Blob<Dstr>;
fn lib_ruby_parser__external__nodes__into_dstr(blob: Blob<Node>) -> Blob<Dstr>;
fn lib_ruby_parser__external__nodes__new_dsym(parts: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_dsym(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_dsym(blob_ptr: *const Blob<Node>) -> *mut Blob<Dsym>;
fn lib_ruby_parser__external__nodes__into_dsym(blob: Blob<Node>) -> Blob<Dsym>;
fn lib_ruby_parser__external__nodes__new_e_flip_flop(left: Blob<Maybe<Ptr<Node>>>, right: Blob<Maybe<Ptr<Node>>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_e_flip_flop(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_e_flip_flop(blob_ptr: *const Blob<Node>) -> *mut Blob<EFlipFlop>;
fn lib_ruby_parser__external__nodes__into_e_flip_flop(blob: Blob<Node>) -> Blob<EFlipFlop>;
fn lib_ruby_parser__external__nodes__new_empty_else(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_empty_else(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_empty_else(blob_ptr: *const Blob<Node>) -> *mut Blob<EmptyElse>;
fn lib_ruby_parser__external__nodes__into_empty_else(blob: Blob<Node>) -> Blob<EmptyElse>;
fn lib_ruby_parser__external__nodes__new_encoding(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_encoding(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_encoding(blob_ptr: *const Blob<Node>) -> *mut Blob<Encoding>;
fn lib_ruby_parser__external__nodes__into_encoding(blob: Blob<Node>) -> Blob<Encoding>;
fn lib_ruby_parser__external__nodes__new_ensure(body: Blob<Maybe<Ptr<Node>>>, ensure: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_ensure(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_ensure(blob_ptr: *const Blob<Node>) -> *mut Blob<Ensure>;
fn lib_ruby_parser__external__nodes__into_ensure(blob: Blob<Node>) -> Blob<Ensure>;
fn lib_ruby_parser__external__nodes__new_erange(left: Blob<Maybe<Ptr<Node>>>, right: Blob<Maybe<Ptr<Node>>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_erange(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_erange(blob_ptr: *const Blob<Node>) -> *mut Blob<Erange>;
fn lib_ruby_parser__external__nodes__into_erange(blob: Blob<Node>) -> Blob<Erange>;
fn lib_ruby_parser__external__nodes__new_false(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_false(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_false(blob_ptr: *const Blob<Node>) -> *mut Blob<False>;
fn lib_ruby_parser__external__nodes__into_false(blob: Blob<Node>) -> Blob<False>;
fn lib_ruby_parser__external__nodes__new_file(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_file(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_file(blob_ptr: *const Blob<Node>) -> *mut Blob<File>;
fn lib_ruby_parser__external__nodes__into_file(blob: Blob<Node>) -> Blob<File>;
fn lib_ruby_parser__external__nodes__new_find_pattern(elements: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_find_pattern(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_find_pattern(blob_ptr: *const Blob<Node>) -> *mut Blob<FindPattern>;
fn lib_ruby_parser__external__nodes__into_find_pattern(blob: Blob<Node>) -> Blob<FindPattern>;
fn lib_ruby_parser__external__nodes__new_float(value: Blob<StringPtr>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_float(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_float(blob_ptr: *const Blob<Node>) -> *mut Blob<Float>;
fn lib_ruby_parser__external__nodes__into_float(blob: Blob<Node>) -> Blob<Float>;
fn lib_ruby_parser__external__nodes__new_for(iterator: Blob<Ptr<Node>>, iteratee: Blob<Ptr<Node>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, operator_l: Blob<Loc>, begin_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_for(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_for(blob_ptr: *const Blob<Node>) -> *mut Blob<For>;
fn lib_ruby_parser__external__nodes__into_for(blob: Blob<Node>) -> Blob<For>;
fn lib_ruby_parser__external__nodes__new_forward_arg(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_forward_arg(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_forward_arg(blob_ptr: *const Blob<Node>) -> *mut Blob<ForwardArg>;
fn lib_ruby_parser__external__nodes__into_forward_arg(blob: Blob<Node>) -> Blob<ForwardArg>;
fn lib_ruby_parser__external__nodes__new_forwarded_args(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_forwarded_args(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_forwarded_args(blob_ptr: *const Blob<Node>) -> *mut Blob<ForwardedArgs>;
fn lib_ruby_parser__external__nodes__into_forwarded_args(blob: Blob<Node>) -> Blob<ForwardedArgs>;
fn lib_ruby_parser__external__nodes__new_gvar(name: Blob<StringPtr>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_gvar(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_gvar(blob_ptr: *const Blob<Node>) -> *mut Blob<Gvar>;
fn lib_ruby_parser__external__nodes__into_gvar(blob: Blob<Node>) -> Blob<Gvar>;
fn lib_ruby_parser__external__nodes__new_gvasgn(name: Blob<StringPtr>, value: Blob<Maybe<Ptr<Node>>>, name_l: Blob<Loc>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_gvasgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_gvasgn(blob_ptr: *const Blob<Node>) -> *mut Blob<Gvasgn>;
fn lib_ruby_parser__external__nodes__into_gvasgn(blob: Blob<Node>) -> Blob<Gvasgn>;
fn lib_ruby_parser__external__nodes__new_hash(pairs: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_hash(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_hash(blob_ptr: *const Blob<Node>) -> *mut Blob<Hash>;
fn lib_ruby_parser__external__nodes__into_hash(blob: Blob<Node>) -> Blob<Hash>;
fn lib_ruby_parser__external__nodes__new_hash_pattern(elements: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_hash_pattern(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_hash_pattern(blob_ptr: *const Blob<Node>) -> *mut Blob<HashPattern>;
fn lib_ruby_parser__external__nodes__into_hash_pattern(blob: Blob<Node>) -> Blob<HashPattern>;
fn lib_ruby_parser__external__nodes__new_heredoc(parts: Blob<List<Node>>, heredoc_body_l: Blob<Loc>, heredoc_end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_heredoc(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_heredoc(blob_ptr: *const Blob<Node>) -> *mut Blob<Heredoc>;
fn lib_ruby_parser__external__nodes__into_heredoc(blob: Blob<Node>) -> Blob<Heredoc>;
fn lib_ruby_parser__external__nodes__new_if(cond: Blob<Ptr<Node>>, if_true: Blob<Maybe<Ptr<Node>>>, if_false: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, begin_l: Blob<Loc>, else_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_if(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_if(blob_ptr: *const Blob<Node>) -> *mut Blob<If>;
fn lib_ruby_parser__external__nodes__into_if(blob: Blob<Node>) -> Blob<If>;
fn lib_ruby_parser__external__nodes__new_if_guard(cond: Blob<Ptr<Node>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_if_guard(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_if_guard(blob_ptr: *const Blob<Node>) -> *mut Blob<IfGuard>;
fn lib_ruby_parser__external__nodes__into_if_guard(blob: Blob<Node>) -> Blob<IfGuard>;
fn lib_ruby_parser__external__nodes__new_i_flip_flop(left: Blob<Maybe<Ptr<Node>>>, right: Blob<Maybe<Ptr<Node>>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_i_flip_flop(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_i_flip_flop(blob_ptr: *const Blob<Node>) -> *mut Blob<IFlipFlop>;
fn lib_ruby_parser__external__nodes__into_i_flip_flop(blob: Blob<Node>) -> Blob<IFlipFlop>;
fn lib_ruby_parser__external__nodes__new_if_mod(cond: Blob<Ptr<Node>>, if_true: Blob<Maybe<Ptr<Node>>>, if_false: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_if_mod(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_if_mod(blob_ptr: *const Blob<Node>) -> *mut Blob<IfMod>;
fn lib_ruby_parser__external__nodes__into_if_mod(blob: Blob<Node>) -> Blob<IfMod>;
fn lib_ruby_parser__external__nodes__new_if_ternary(cond: Blob<Ptr<Node>>, if_true: Blob<Ptr<Node>>, if_false: Blob<Ptr<Node>>, question_l: Blob<Loc>, colon_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_if_ternary(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_if_ternary(blob_ptr: *const Blob<Node>) -> *mut Blob<IfTernary>;
fn lib_ruby_parser__external__nodes__into_if_ternary(blob: Blob<Node>) -> Blob<IfTernary>;
fn lib_ruby_parser__external__nodes__new_index(recv: Blob<Ptr<Node>>, indexes: Blob<List<Node>>, begin_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_index(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_index(blob_ptr: *const Blob<Node>) -> *mut Blob<Index>;
fn lib_ruby_parser__external__nodes__into_index(blob: Blob<Node>) -> Blob<Index>;
fn lib_ruby_parser__external__nodes__new_index_asgn(recv: Blob<Ptr<Node>>, indexes: Blob<List<Node>>, value: Blob<Maybe<Ptr<Node>>>, begin_l: Blob<Loc>, end_l: Blob<Loc>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_index_asgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_index_asgn(blob_ptr: *const Blob<Node>) -> *mut Blob<IndexAsgn>;
fn lib_ruby_parser__external__nodes__into_index_asgn(blob: Blob<Node>) -> Blob<IndexAsgn>;
fn lib_ruby_parser__external__nodes__new_in_pattern(pattern: Blob<Ptr<Node>>, guard: Blob<Maybe<Ptr<Node>>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, begin_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_in_pattern(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_in_pattern(blob_ptr: *const Blob<Node>) -> *mut Blob<InPattern>;
fn lib_ruby_parser__external__nodes__into_in_pattern(blob: Blob<Node>) -> Blob<InPattern>;
fn lib_ruby_parser__external__nodes__new_int(value: Blob<StringPtr>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_int(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_int(blob_ptr: *const Blob<Node>) -> *mut Blob<Int>;
fn lib_ruby_parser__external__nodes__into_int(blob: Blob<Node>) -> Blob<Int>;
fn lib_ruby_parser__external__nodes__new_irange(left: Blob<Maybe<Ptr<Node>>>, right: Blob<Maybe<Ptr<Node>>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_irange(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_irange(blob_ptr: *const Blob<Node>) -> *mut Blob<Irange>;
fn lib_ruby_parser__external__nodes__into_irange(blob: Blob<Node>) -> Blob<Irange>;
fn lib_ruby_parser__external__nodes__new_ivar(name: Blob<StringPtr>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_ivar(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_ivar(blob_ptr: *const Blob<Node>) -> *mut Blob<Ivar>;
fn lib_ruby_parser__external__nodes__into_ivar(blob: Blob<Node>) -> Blob<Ivar>;
fn lib_ruby_parser__external__nodes__new_ivasgn(name: Blob<StringPtr>, value: Blob<Maybe<Ptr<Node>>>, name_l: Blob<Loc>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_ivasgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_ivasgn(blob_ptr: *const Blob<Node>) -> *mut Blob<Ivasgn>;
fn lib_ruby_parser__external__nodes__into_ivasgn(blob: Blob<Node>) -> Blob<Ivasgn>;
fn lib_ruby_parser__external__nodes__new_kwarg(name: Blob<StringPtr>, name_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_kwarg(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_kwarg(blob_ptr: *const Blob<Node>) -> *mut Blob<Kwarg>;
fn lib_ruby_parser__external__nodes__into_kwarg(blob: Blob<Node>) -> Blob<Kwarg>;
fn lib_ruby_parser__external__nodes__new_kwargs(pairs: Blob<List<Node>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_kwargs(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_kwargs(blob_ptr: *const Blob<Node>) -> *mut Blob<Kwargs>;
fn lib_ruby_parser__external__nodes__into_kwargs(blob: Blob<Node>) -> Blob<Kwargs>;
fn lib_ruby_parser__external__nodes__new_kw_begin(statements: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_kw_begin(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_kw_begin(blob_ptr: *const Blob<Node>) -> *mut Blob<KwBegin>;
fn lib_ruby_parser__external__nodes__into_kw_begin(blob: Blob<Node>) -> Blob<KwBegin>;
fn lib_ruby_parser__external__nodes__new_kwnilarg(name_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_kwnilarg(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_kwnilarg(blob_ptr: *const Blob<Node>) -> *mut Blob<Kwnilarg>;
fn lib_ruby_parser__external__nodes__into_kwnilarg(blob: Blob<Node>) -> Blob<Kwnilarg>;
fn lib_ruby_parser__external__nodes__new_kwoptarg(name: Blob<StringPtr>, default: Blob<Ptr<Node>>, name_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_kwoptarg(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_kwoptarg(blob_ptr: *const Blob<Node>) -> *mut Blob<Kwoptarg>;
fn lib_ruby_parser__external__nodes__into_kwoptarg(blob: Blob<Node>) -> Blob<Kwoptarg>;
fn lib_ruby_parser__external__nodes__new_kwrestarg(name: Blob<Maybe<StringPtr>>, operator_l: Blob<Loc>, name_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_kwrestarg(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_kwrestarg(blob_ptr: *const Blob<Node>) -> *mut Blob<Kwrestarg>;
fn lib_ruby_parser__external__nodes__into_kwrestarg(blob: Blob<Node>) -> Blob<Kwrestarg>;
fn lib_ruby_parser__external__nodes__new_kwsplat(value: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_kwsplat(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_kwsplat(blob_ptr: *const Blob<Node>) -> *mut Blob<Kwsplat>;
fn lib_ruby_parser__external__nodes__into_kwsplat(blob: Blob<Node>) -> Blob<Kwsplat>;
fn lib_ruby_parser__external__nodes__new_lambda(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_lambda(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_lambda(blob_ptr: *const Blob<Node>) -> *mut Blob<Lambda>;
fn lib_ruby_parser__external__nodes__into_lambda(blob: Blob<Node>) -> Blob<Lambda>;
fn lib_ruby_parser__external__nodes__new_line(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_line(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_line(blob_ptr: *const Blob<Node>) -> *mut Blob<Line>;
fn lib_ruby_parser__external__nodes__into_line(blob: Blob<Node>) -> Blob<Line>;
fn lib_ruby_parser__external__nodes__new_lvar(name: Blob<StringPtr>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_lvar(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_lvar(blob_ptr: *const Blob<Node>) -> *mut Blob<Lvar>;
fn lib_ruby_parser__external__nodes__into_lvar(blob: Blob<Node>) -> Blob<Lvar>;
fn lib_ruby_parser__external__nodes__new_lvasgn(name: Blob<StringPtr>, value: Blob<Maybe<Ptr<Node>>>, name_l: Blob<Loc>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_lvasgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_lvasgn(blob_ptr: *const Blob<Node>) -> *mut Blob<Lvasgn>;
fn lib_ruby_parser__external__nodes__into_lvasgn(blob: Blob<Node>) -> Blob<Lvasgn>;
fn lib_ruby_parser__external__nodes__new_masgn(lhs: Blob<Ptr<Node>>, rhs: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_masgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_masgn(blob_ptr: *const Blob<Node>) -> *mut Blob<Masgn>;
fn lib_ruby_parser__external__nodes__into_masgn(blob: Blob<Node>) -> Blob<Masgn>;
fn lib_ruby_parser__external__nodes__new_match_alt(lhs: Blob<Ptr<Node>>, rhs: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_match_alt(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_match_alt(blob_ptr: *const Blob<Node>) -> *mut Blob<MatchAlt>;
fn lib_ruby_parser__external__nodes__into_match_alt(blob: Blob<Node>) -> Blob<MatchAlt>;
fn lib_ruby_parser__external__nodes__new_match_as(value: Blob<Ptr<Node>>, as_: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_match_as(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_match_as(blob_ptr: *const Blob<Node>) -> *mut Blob<MatchAs>;
fn lib_ruby_parser__external__nodes__into_match_as(blob: Blob<Node>) -> Blob<MatchAs>;
fn lib_ruby_parser__external__nodes__new_match_current_line(re: Blob<Ptr<Node>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_match_current_line(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_match_current_line(blob_ptr: *const Blob<Node>) -> *mut Blob<MatchCurrentLine>;
fn lib_ruby_parser__external__nodes__into_match_current_line(blob: Blob<Node>) -> Blob<MatchCurrentLine>;
fn lib_ruby_parser__external__nodes__new_match_nil_pattern(operator_l: Blob<Loc>, name_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_match_nil_pattern(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_match_nil_pattern(blob_ptr: *const Blob<Node>) -> *mut Blob<MatchNilPattern>;
fn lib_ruby_parser__external__nodes__into_match_nil_pattern(blob: Blob<Node>) -> Blob<MatchNilPattern>;
fn lib_ruby_parser__external__nodes__new_match_pattern(value: Blob<Ptr<Node>>, pattern: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_match_pattern(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_match_pattern(blob_ptr: *const Blob<Node>) -> *mut Blob<MatchPattern>;
fn lib_ruby_parser__external__nodes__into_match_pattern(blob: Blob<Node>) -> Blob<MatchPattern>;
fn lib_ruby_parser__external__nodes__new_match_pattern_p(value: Blob<Ptr<Node>>, pattern: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_match_pattern_p(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_match_pattern_p(blob_ptr: *const Blob<Node>) -> *mut Blob<MatchPatternP>;
fn lib_ruby_parser__external__nodes__into_match_pattern_p(blob: Blob<Node>) -> Blob<MatchPatternP>;
fn lib_ruby_parser__external__nodes__new_match_rest(name: Blob<Maybe<Ptr<Node>>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_match_rest(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_match_rest(blob_ptr: *const Blob<Node>) -> *mut Blob<MatchRest>;
fn lib_ruby_parser__external__nodes__into_match_rest(blob: Blob<Node>) -> Blob<MatchRest>;
fn lib_ruby_parser__external__nodes__new_match_var(name: Blob<StringPtr>, name_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_match_var(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_match_var(blob_ptr: *const Blob<Node>) -> *mut Blob<MatchVar>;
fn lib_ruby_parser__external__nodes__into_match_var(blob: Blob<Node>) -> Blob<MatchVar>;
fn lib_ruby_parser__external__nodes__new_match_with_lvasgn(re: Blob<Ptr<Node>>, value: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_match_with_lvasgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_match_with_lvasgn(blob_ptr: *const Blob<Node>) -> *mut Blob<MatchWithLvasgn>;
fn lib_ruby_parser__external__nodes__into_match_with_lvasgn(blob: Blob<Node>) -> Blob<MatchWithLvasgn>;
fn lib_ruby_parser__external__nodes__new_mlhs(items: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_mlhs(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_mlhs(blob_ptr: *const Blob<Node>) -> *mut Blob<Mlhs>;
fn lib_ruby_parser__external__nodes__into_mlhs(blob: Blob<Node>) -> Blob<Mlhs>;
fn lib_ruby_parser__external__nodes__new_module(name: Blob<Ptr<Node>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_module(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_module(blob_ptr: *const Blob<Node>) -> *mut Blob<Module>;
fn lib_ruby_parser__external__nodes__into_module(blob: Blob<Node>) -> Blob<Module>;
fn lib_ruby_parser__external__nodes__new_next(args: Blob<List<Node>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_next(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_next(blob_ptr: *const Blob<Node>) -> *mut Blob<Next>;
fn lib_ruby_parser__external__nodes__into_next(blob: Blob<Node>) -> Blob<Next>;
fn lib_ruby_parser__external__nodes__new_nil(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_nil(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_nil(blob_ptr: *const Blob<Node>) -> *mut Blob<Nil>;
fn lib_ruby_parser__external__nodes__into_nil(blob: Blob<Node>) -> Blob<Nil>;
fn lib_ruby_parser__external__nodes__new_nth_ref(name: Blob<StringPtr>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_nth_ref(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_nth_ref(blob_ptr: *const Blob<Node>) -> *mut Blob<NthRef>;
fn lib_ruby_parser__external__nodes__into_nth_ref(blob: Blob<Node>) -> Blob<NthRef>;
fn lib_ruby_parser__external__nodes__new_numblock(call: Blob<Ptr<Node>>, numargs: Blob<u8>, body: Blob<Ptr<Node>>, begin_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_numblock(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_numblock(blob_ptr: *const Blob<Node>) -> *mut Blob<Numblock>;
fn lib_ruby_parser__external__nodes__into_numblock(blob: Blob<Node>) -> Blob<Numblock>;
fn lib_ruby_parser__external__nodes__new_op_asgn(recv: Blob<Ptr<Node>>, operator: Blob<StringPtr>, value: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_op_asgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_op_asgn(blob_ptr: *const Blob<Node>) -> *mut Blob<OpAsgn>;
fn lib_ruby_parser__external__nodes__into_op_asgn(blob: Blob<Node>) -> Blob<OpAsgn>;
fn lib_ruby_parser__external__nodes__new_optarg(name: Blob<StringPtr>, default: Blob<Ptr<Node>>, name_l: Blob<Loc>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_optarg(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_optarg(blob_ptr: *const Blob<Node>) -> *mut Blob<Optarg>;
fn lib_ruby_parser__external__nodes__into_optarg(blob: Blob<Node>) -> Blob<Optarg>;
fn lib_ruby_parser__external__nodes__new_or(lhs: Blob<Ptr<Node>>, rhs: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_or(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_or(blob_ptr: *const Blob<Node>) -> *mut Blob<Or>;
fn lib_ruby_parser__external__nodes__into_or(blob: Blob<Node>) -> Blob<Or>;
fn lib_ruby_parser__external__nodes__new_or_asgn(recv: Blob<Ptr<Node>>, value: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_or_asgn(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_or_asgn(blob_ptr: *const Blob<Node>) -> *mut Blob<OrAsgn>;
fn lib_ruby_parser__external__nodes__into_or_asgn(blob: Blob<Node>) -> Blob<OrAsgn>;
fn lib_ruby_parser__external__nodes__new_pair(key: Blob<Ptr<Node>>, value: Blob<Ptr<Node>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_pair(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_pair(blob_ptr: *const Blob<Node>) -> *mut Blob<Pair>;
fn lib_ruby_parser__external__nodes__into_pair(blob: Blob<Node>) -> Blob<Pair>;
fn lib_ruby_parser__external__nodes__new_pin(var: Blob<Ptr<Node>>, selector_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_pin(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_pin(blob_ptr: *const Blob<Node>) -> *mut Blob<Pin>;
fn lib_ruby_parser__external__nodes__into_pin(blob: Blob<Node>) -> Blob<Pin>;
fn lib_ruby_parser__external__nodes__new_postexe(body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, begin_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_postexe(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_postexe(blob_ptr: *const Blob<Node>) -> *mut Blob<Postexe>;
fn lib_ruby_parser__external__nodes__into_postexe(blob: Blob<Node>) -> Blob<Postexe>;
fn lib_ruby_parser__external__nodes__new_preexe(body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, begin_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_preexe(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_preexe(blob_ptr: *const Blob<Node>) -> *mut Blob<Preexe>;
fn lib_ruby_parser__external__nodes__into_preexe(blob: Blob<Node>) -> Blob<Preexe>;
fn lib_ruby_parser__external__nodes__new_procarg0(args: Blob<List<Node>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_procarg0(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_procarg0(blob_ptr: *const Blob<Node>) -> *mut Blob<Procarg0>;
fn lib_ruby_parser__external__nodes__into_procarg0(blob: Blob<Node>) -> Blob<Procarg0>;
fn lib_ruby_parser__external__nodes__new_rational(value: Blob<StringPtr>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_rational(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_rational(blob_ptr: *const Blob<Node>) -> *mut Blob<Rational>;
fn lib_ruby_parser__external__nodes__into_rational(blob: Blob<Node>) -> Blob<Rational>;
fn lib_ruby_parser__external__nodes__new_redo(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_redo(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_redo(blob_ptr: *const Blob<Node>) -> *mut Blob<Redo>;
fn lib_ruby_parser__external__nodes__into_redo(blob: Blob<Node>) -> Blob<Redo>;
fn lib_ruby_parser__external__nodes__new_regexp(parts: Blob<List<Node>>, options: Blob<Maybe<Ptr<Node>>>, begin_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_regexp(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_regexp(blob_ptr: *const Blob<Node>) -> *mut Blob<Regexp>;
fn lib_ruby_parser__external__nodes__into_regexp(blob: Blob<Node>) -> Blob<Regexp>;
fn lib_ruby_parser__external__nodes__new_reg_opt(options: Blob<Maybe<StringPtr>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_reg_opt(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_reg_opt(blob_ptr: *const Blob<Node>) -> *mut Blob<RegOpt>;
fn lib_ruby_parser__external__nodes__into_reg_opt(blob: Blob<Node>) -> Blob<RegOpt>;
fn lib_ruby_parser__external__nodes__new_rescue(body: Blob<Maybe<Ptr<Node>>>, rescue_bodies: Blob<List<Node>>, else_: Blob<Maybe<Ptr<Node>>>, else_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_rescue(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_rescue(blob_ptr: *const Blob<Node>) -> *mut Blob<Rescue>;
fn lib_ruby_parser__external__nodes__into_rescue(blob: Blob<Node>) -> Blob<Rescue>;
fn lib_ruby_parser__external__nodes__new_rescue_body(exc_list: Blob<Maybe<Ptr<Node>>>, exc_var: Blob<Maybe<Ptr<Node>>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, assoc_l: Blob<Maybe<Loc>>, begin_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_rescue_body(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_rescue_body(blob_ptr: *const Blob<Node>) -> *mut Blob<RescueBody>;
fn lib_ruby_parser__external__nodes__into_rescue_body(blob: Blob<Node>) -> Blob<RescueBody>;
fn lib_ruby_parser__external__nodes__new_restarg(name: Blob<Maybe<StringPtr>>, operator_l: Blob<Loc>, name_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_restarg(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_restarg(blob_ptr: *const Blob<Node>) -> *mut Blob<Restarg>;
fn lib_ruby_parser__external__nodes__into_restarg(blob: Blob<Node>) -> Blob<Restarg>;
fn lib_ruby_parser__external__nodes__new_retry(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_retry(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_retry(blob_ptr: *const Blob<Node>) -> *mut Blob<Retry>;
fn lib_ruby_parser__external__nodes__into_retry(blob: Blob<Node>) -> Blob<Retry>;
fn lib_ruby_parser__external__nodes__new_return(args: Blob<List<Node>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_return(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_return(blob_ptr: *const Blob<Node>) -> *mut Blob<Return>;
fn lib_ruby_parser__external__nodes__into_return(blob: Blob<Node>) -> Blob<Return>;
fn lib_ruby_parser__external__nodes__new_s_class(expr: Blob<Ptr<Node>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, operator_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_s_class(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_s_class(blob_ptr: *const Blob<Node>) -> *mut Blob<SClass>;
fn lib_ruby_parser__external__nodes__into_s_class(blob: Blob<Node>) -> Blob<SClass>;
fn lib_ruby_parser__external__nodes__new_self_(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_self_(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_self_(blob_ptr: *const Blob<Node>) -> *mut Blob<Self_>;
fn lib_ruby_parser__external__nodes__into_self_(blob: Blob<Node>) -> Blob<Self_>;
fn lib_ruby_parser__external__nodes__new_send(recv: Blob<Maybe<Ptr<Node>>>, method_name: Blob<StringPtr>, args: Blob<List<Node>>, dot_l: Blob<Maybe<Loc>>, selector_l: Blob<Maybe<Loc>>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, operator_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_send(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_send(blob_ptr: *const Blob<Node>) -> *mut Blob<Send>;
fn lib_ruby_parser__external__nodes__into_send(blob: Blob<Node>) -> Blob<Send>;
fn lib_ruby_parser__external__nodes__new_shadowarg(name: Blob<StringPtr>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_shadowarg(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_shadowarg(blob_ptr: *const Blob<Node>) -> *mut Blob<Shadowarg>;
fn lib_ruby_parser__external__nodes__into_shadowarg(blob: Blob<Node>) -> Blob<Shadowarg>;
fn lib_ruby_parser__external__nodes__new_splat(value: Blob<Maybe<Ptr<Node>>>, operator_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_splat(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_splat(blob_ptr: *const Blob<Node>) -> *mut Blob<Splat>;
fn lib_ruby_parser__external__nodes__into_splat(blob: Blob<Node>) -> Blob<Splat>;
fn lib_ruby_parser__external__nodes__new_str(value: Blob<Bytes>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_str(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_str(blob_ptr: *const Blob<Node>) -> *mut Blob<Str>;
fn lib_ruby_parser__external__nodes__into_str(blob: Blob<Node>) -> Blob<Str>;
fn lib_ruby_parser__external__nodes__new_super(args: Blob<List<Node>>, keyword_l: Blob<Loc>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_super(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_super(blob_ptr: *const Blob<Node>) -> *mut Blob<Super>;
fn lib_ruby_parser__external__nodes__into_super(blob: Blob<Node>) -> Blob<Super>;
fn lib_ruby_parser__external__nodes__new_sym(name: Blob<Bytes>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_sym(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_sym(blob_ptr: *const Blob<Node>) -> *mut Blob<Sym>;
fn lib_ruby_parser__external__nodes__into_sym(blob: Blob<Node>) -> Blob<Sym>;
fn lib_ruby_parser__external__nodes__new_true(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_true(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_true(blob_ptr: *const Blob<Node>) -> *mut Blob<True>;
fn lib_ruby_parser__external__nodes__into_true(blob: Blob<Node>) -> Blob<True>;
fn lib_ruby_parser__external__nodes__new_undef(names: Blob<List<Node>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_undef(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_undef(blob_ptr: *const Blob<Node>) -> *mut Blob<Undef>;
fn lib_ruby_parser__external__nodes__into_undef(blob: Blob<Node>) -> Blob<Undef>;
fn lib_ruby_parser__external__nodes__new_unless_guard(cond: Blob<Ptr<Node>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_unless_guard(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_unless_guard(blob_ptr: *const Blob<Node>) -> *mut Blob<UnlessGuard>;
fn lib_ruby_parser__external__nodes__into_unless_guard(blob: Blob<Node>) -> Blob<UnlessGuard>;
fn lib_ruby_parser__external__nodes__new_until(cond: Blob<Ptr<Node>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_until(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_until(blob_ptr: *const Blob<Node>) -> *mut Blob<Until>;
fn lib_ruby_parser__external__nodes__into_until(blob: Blob<Node>) -> Blob<Until>;
fn lib_ruby_parser__external__nodes__new_until_post(cond: Blob<Ptr<Node>>, body: Blob<Ptr<Node>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_until_post(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_until_post(blob_ptr: *const Blob<Node>) -> *mut Blob<UntilPost>;
fn lib_ruby_parser__external__nodes__into_until_post(blob: Blob<Node>) -> Blob<UntilPost>;
fn lib_ruby_parser__external__nodes__new_when(patterns: Blob<List<Node>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, begin_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_when(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_when(blob_ptr: *const Blob<Node>) -> *mut Blob<When>;
fn lib_ruby_parser__external__nodes__into_when(blob: Blob<Node>) -> Blob<When>;
fn lib_ruby_parser__external__nodes__new_while(cond: Blob<Ptr<Node>>, body: Blob<Maybe<Ptr<Node>>>, keyword_l: Blob<Loc>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_while(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_while(blob_ptr: *const Blob<Node>) -> *mut Blob<While>;
fn lib_ruby_parser__external__nodes__into_while(blob: Blob<Node>) -> Blob<While>;
fn lib_ruby_parser__external__nodes__new_while_post(cond: Blob<Ptr<Node>>, body: Blob<Ptr<Node>>, keyword_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_while_post(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_while_post(blob_ptr: *const Blob<Node>) -> *mut Blob<WhilePost>;
fn lib_ruby_parser__external__nodes__into_while_post(blob: Blob<Node>) -> Blob<WhilePost>;
fn lib_ruby_parser__external__nodes__new_x_heredoc(parts: Blob<List<Node>>, heredoc_body_l: Blob<Loc>, heredoc_end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_x_heredoc(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_x_heredoc(blob_ptr: *const Blob<Node>) -> *mut Blob<XHeredoc>;
fn lib_ruby_parser__external__nodes__into_x_heredoc(blob: Blob<Node>) -> Blob<XHeredoc>;
fn lib_ruby_parser__external__nodes__new_xstr(parts: Blob<List<Node>>, begin_l: Blob<Loc>, end_l: Blob<Loc>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_xstr(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_xstr(blob_ptr: *const Blob<Node>) -> *mut Blob<Xstr>;
fn lib_ruby_parser__external__nodes__into_xstr(blob: Blob<Node>) -> Blob<Xstr>;
fn lib_ruby_parser__external__nodes__new_yield(args: Blob<List<Node>>, keyword_l: Blob<Loc>, begin_l: Blob<Maybe<Loc>>, end_l: Blob<Maybe<Loc>>, expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_yield(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_yield(blob_ptr: *const Blob<Node>) -> *mut Blob<Yield>;
fn lib_ruby_parser__external__nodes__into_yield(blob: Blob<Node>) -> Blob<Yield>;
fn lib_ruby_parser__external__nodes__new_z_super(expression_l: Blob<Loc>, ) -> Blob<Node>;
fn lib_ruby_parser__external__nodes__is_z_super(blob_ptr: *const Blob<Node>) -> bool;
fn lib_ruby_parser__external__nodes__get_z_super(blob_ptr: *const Blob<Node>) -> *mut Blob<ZSuper>;
fn lib_ruby_parser__external__nodes__into_z_super(blob: Blob<Node>) -> Blob<ZSuper>;
fn lib_ruby_parser__external__node__drop(blob: *mut Blob<Node>);
}
impl Drop for Node {
fn drop(&mut self) {
unsafe { lib_ruby_parser__external__node__drop(&mut self.blob) }
}
}