use super::LocName;
use crate::{Node, Loc};
use crate::nodes::*;
impl LocName {
fn get_begin_l(node: &Node) -> Option<Loc> {
match node {
Node::Args(Args { begin_l, .. })
| Node::Array(Array { begin_l, .. })
| Node::ArrayPattern(ArrayPattern { begin_l, .. })
| Node::ArrayPatternWithTail(ArrayPatternWithTail { begin_l, .. })
| Node::Begin(Begin { begin_l, .. })
| Node::CSend(CSend { begin_l, .. })
| Node::Defined(Defined { begin_l, .. })
| Node::Dstr(Dstr { begin_l, .. })
| Node::Dsym(Dsym { begin_l, .. })
| Node::FindPattern(FindPattern { begin_l, .. })
| Node::Hash(Hash { begin_l, .. })
| Node::HashPattern(HashPattern { begin_l, .. })
| Node::KwBegin(KwBegin { begin_l, .. })
| Node::Mlhs(Mlhs { begin_l, .. })
| Node::Procarg0(Procarg0 { begin_l, .. })
| Node::RescueBody(RescueBody { begin_l, .. })
| Node::Send(Send { begin_l, .. })
| Node::Str(Str { begin_l, .. })
| Node::Super(Super { begin_l, .. })
| Node::Sym(Sym { begin_l, .. })
| Node::Until(Until { begin_l, .. })
| Node::While(While { begin_l, .. })
| Node::Yield(Yield { begin_l, .. }) => begin_l.clone(),
Node::Block(Block { begin_l, .. })
| Node::ConstPattern(ConstPattern { begin_l, .. })
| Node::For(For { begin_l, .. })
| Node::If(If { begin_l, .. })
| Node::Index(Index { begin_l, .. })
| Node::IndexAsgn(IndexAsgn { begin_l, .. })
| Node::InPattern(InPattern { begin_l, .. })
| Node::Numblock(Numblock { begin_l, .. })
| Node::Postexe(Postexe { begin_l, .. })
| Node::Preexe(Preexe { begin_l, .. })
| Node::Regexp(Regexp { begin_l, .. })
| Node::When(When { begin_l, .. })
| Node::Xstr(Xstr { begin_l, .. }) => Some(begin_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support begin_l loc", node.str_type())
}
}
}
fn get_end_l(node: &Node) -> Option<Loc> {
match node {
Node::Args(Args { end_l, .. })
| Node::Array(Array { end_l, .. })
| Node::ArrayPattern(ArrayPattern { end_l, .. })
| Node::ArrayPatternWithTail(ArrayPatternWithTail { end_l, .. })
| Node::Begin(Begin { end_l, .. })
| Node::CSend(CSend { end_l, .. })
| Node::Def(Def { end_l, .. })
| Node::Defined(Defined { end_l, .. })
| Node::Defs(Defs { end_l, .. })
| Node::Dstr(Dstr { end_l, .. })
| Node::Dsym(Dsym { end_l, .. })
| Node::FindPattern(FindPattern { end_l, .. })
| Node::Hash(Hash { end_l, .. })
| Node::HashPattern(HashPattern { end_l, .. })
| Node::If(If { end_l, .. })
| Node::KwBegin(KwBegin { end_l, .. })
| Node::Mlhs(Mlhs { end_l, .. })
| Node::Procarg0(Procarg0 { end_l, .. })
| Node::Send(Send { end_l, .. })
| Node::Str(Str { end_l, .. })
| Node::Super(Super { end_l, .. })
| Node::Sym(Sym { end_l, .. })
| Node::Until(Until { end_l, .. })
| Node::While(While { end_l, .. })
| Node::Yield(Yield { end_l, .. }) => end_l.clone(),
Node::Block(Block { end_l, .. })
| Node::Case(Case { end_l, .. })
| Node::CaseMatch(CaseMatch { end_l, .. })
| Node::Class(Class { end_l, .. })
| Node::ConstPattern(ConstPattern { end_l, .. })
| Node::For(For { end_l, .. })
| Node::Index(Index { end_l, .. })
| Node::IndexAsgn(IndexAsgn { end_l, .. })
| Node::Module(Module { end_l, .. })
| Node::Numblock(Numblock { end_l, .. })
| Node::Postexe(Postexe { end_l, .. })
| Node::Preexe(Preexe { end_l, .. })
| Node::Regexp(Regexp { end_l, .. })
| Node::SClass(SClass { end_l, .. })
| Node::Xstr(Xstr { end_l, .. }) => Some(end_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support end_l loc", node.str_type())
}
}
}
fn get_expression_l(node: &Node) -> Option<Loc> {
match node {
Node::Alias(Alias { expression_l, .. })
| Node::And(And { expression_l, .. })
| Node::AndAsgn(AndAsgn { expression_l, .. })
| Node::Arg(Arg { expression_l, .. })
| Node::Args(Args { expression_l, .. })
| Node::Array(Array { expression_l, .. })
| Node::ArrayPattern(ArrayPattern { expression_l, .. })
| Node::ArrayPatternWithTail(ArrayPatternWithTail { expression_l, .. })
| Node::BackRef(BackRef { expression_l, .. })
| Node::Begin(Begin { expression_l, .. })
| Node::Block(Block { expression_l, .. })
| Node::Blockarg(Blockarg { expression_l, .. })
| Node::BlockPass(BlockPass { expression_l, .. })
| Node::Break(Break { expression_l, .. })
| Node::Case(Case { expression_l, .. })
| Node::CaseMatch(CaseMatch { expression_l, .. })
| Node::Casgn(Casgn { expression_l, .. })
| Node::Cbase(Cbase { expression_l, .. })
| Node::Class(Class { expression_l, .. })
| Node::Complex(Complex { expression_l, .. })
| Node::Const(Const { expression_l, .. })
| Node::ConstPattern(ConstPattern { expression_l, .. })
| Node::CSend(CSend { expression_l, .. })
| Node::Cvar(Cvar { expression_l, .. })
| Node::Cvasgn(Cvasgn { expression_l, .. })
| Node::Def(Def { expression_l, .. })
| Node::Defined(Defined { expression_l, .. })
| Node::Defs(Defs { expression_l, .. })
| Node::Dstr(Dstr { expression_l, .. })
| Node::Dsym(Dsym { expression_l, .. })
| Node::EFlipFlop(EFlipFlop { expression_l, .. })
| Node::EmptyElse(EmptyElse { expression_l, .. })
| Node::Encoding(Encoding { expression_l, .. })
| Node::Ensure(Ensure { expression_l, .. })
| Node::Erange(Erange { expression_l, .. })
| Node::False(False { expression_l, .. })
| Node::File(File { expression_l, .. })
| Node::FindPattern(FindPattern { expression_l, .. })
| Node::Float(Float { expression_l, .. })
| Node::For(For { expression_l, .. })
| Node::ForwardArg(ForwardArg { expression_l, .. })
| Node::ForwardedArgs(ForwardedArgs { expression_l, .. })
| Node::Gvar(Gvar { expression_l, .. })
| Node::Gvasgn(Gvasgn { expression_l, .. })
| Node::Hash(Hash { expression_l, .. })
| Node::HashPattern(HashPattern { expression_l, .. })
| Node::Heredoc(Heredoc { expression_l, .. })
| Node::If(If { expression_l, .. })
| Node::IfGuard(IfGuard { expression_l, .. })
| Node::IFlipFlop(IFlipFlop { expression_l, .. })
| Node::IfMod(IfMod { expression_l, .. })
| Node::IfTernary(IfTernary { expression_l, .. })
| Node::Index(Index { expression_l, .. })
| Node::IndexAsgn(IndexAsgn { expression_l, .. })
| Node::InPattern(InPattern { expression_l, .. })
| Node::Int(Int { expression_l, .. })
| Node::Irange(Irange { expression_l, .. })
| Node::Ivar(Ivar { expression_l, .. })
| Node::Ivasgn(Ivasgn { expression_l, .. })
| Node::Kwarg(Kwarg { expression_l, .. })
| Node::Kwargs(Kwargs { expression_l, .. })
| Node::KwBegin(KwBegin { expression_l, .. })
| Node::Kwnilarg(Kwnilarg { expression_l, .. })
| Node::Kwoptarg(Kwoptarg { expression_l, .. })
| Node::Kwrestarg(Kwrestarg { expression_l, .. })
| Node::Kwsplat(Kwsplat { expression_l, .. })
| Node::Lambda(Lambda { expression_l, .. })
| Node::Line(Line { expression_l, .. })
| Node::Lvar(Lvar { expression_l, .. })
| Node::Lvasgn(Lvasgn { expression_l, .. })
| Node::Masgn(Masgn { expression_l, .. })
| Node::MatchAlt(MatchAlt { expression_l, .. })
| Node::MatchAs(MatchAs { expression_l, .. })
| Node::MatchCurrentLine(MatchCurrentLine { expression_l, .. })
| Node::MatchNilPattern(MatchNilPattern { expression_l, .. })
| Node::MatchPattern(MatchPattern { expression_l, .. })
| Node::MatchPatternP(MatchPatternP { expression_l, .. })
| Node::MatchRest(MatchRest { expression_l, .. })
| Node::MatchVar(MatchVar { expression_l, .. })
| Node::MatchWithLvasgn(MatchWithLvasgn { expression_l, .. })
| Node::Mlhs(Mlhs { expression_l, .. })
| Node::Module(Module { expression_l, .. })
| Node::Next(Next { expression_l, .. })
| Node::Nil(Nil { expression_l, .. })
| Node::NthRef(NthRef { expression_l, .. })
| Node::Numblock(Numblock { expression_l, .. })
| Node::OpAsgn(OpAsgn { expression_l, .. })
| Node::Optarg(Optarg { expression_l, .. })
| Node::Or(Or { expression_l, .. })
| Node::OrAsgn(OrAsgn { expression_l, .. })
| Node::Pair(Pair { expression_l, .. })
| Node::Pin(Pin { expression_l, .. })
| Node::Postexe(Postexe { expression_l, .. })
| Node::Preexe(Preexe { expression_l, .. })
| Node::Procarg0(Procarg0 { expression_l, .. })
| Node::Rational(Rational { expression_l, .. })
| Node::Redo(Redo { expression_l, .. })
| Node::Regexp(Regexp { expression_l, .. })
| Node::RegOpt(RegOpt { expression_l, .. })
| Node::Rescue(Rescue { expression_l, .. })
| Node::RescueBody(RescueBody { expression_l, .. })
| Node::Restarg(Restarg { expression_l, .. })
| Node::Retry(Retry { expression_l, .. })
| Node::Return(Return { expression_l, .. })
| Node::SClass(SClass { expression_l, .. })
| Node::Self_(Self_ { expression_l, .. })
| Node::Send(Send { expression_l, .. })
| Node::Shadowarg(Shadowarg { expression_l, .. })
| Node::Splat(Splat { expression_l, .. })
| Node::Str(Str { expression_l, .. })
| Node::Super(Super { expression_l, .. })
| Node::Sym(Sym { expression_l, .. })
| Node::True(True { expression_l, .. })
| Node::Undef(Undef { expression_l, .. })
| Node::UnlessGuard(UnlessGuard { expression_l, .. })
| Node::Until(Until { expression_l, .. })
| Node::UntilPost(UntilPost { expression_l, .. })
| Node::When(When { expression_l, .. })
| Node::While(While { expression_l, .. })
| Node::WhilePost(WhilePost { expression_l, .. })
| Node::XHeredoc(XHeredoc { expression_l, .. })
| Node::Xstr(Xstr { expression_l, .. })
| Node::Yield(Yield { expression_l, .. })
| Node::ZSuper(ZSuper { expression_l, .. }) => Some(expression_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support expression_l loc", node.str_type())
}
}
}
fn get_keyword_l(node: &Node) -> Option<Loc> {
match node {
Node::Alias(Alias { keyword_l, .. })
| Node::Break(Break { keyword_l, .. })
| Node::Case(Case { keyword_l, .. })
| Node::CaseMatch(CaseMatch { keyword_l, .. })
| Node::Class(Class { keyword_l, .. })
| Node::Def(Def { keyword_l, .. })
| Node::Defined(Defined { keyword_l, .. })
| Node::Defs(Defs { keyword_l, .. })
| Node::Ensure(Ensure { keyword_l, .. })
| Node::For(For { keyword_l, .. })
| Node::If(If { keyword_l, .. })
| Node::IfGuard(IfGuard { keyword_l, .. })
| Node::IfMod(IfMod { keyword_l, .. })
| Node::InPattern(InPattern { keyword_l, .. })
| Node::Module(Module { keyword_l, .. })
| Node::Next(Next { keyword_l, .. })
| Node::Postexe(Postexe { keyword_l, .. })
| Node::Preexe(Preexe { keyword_l, .. })
| Node::RescueBody(RescueBody { keyword_l, .. })
| Node::Return(Return { keyword_l, .. })
| Node::SClass(SClass { keyword_l, .. })
| Node::Super(Super { keyword_l, .. })
| Node::Undef(Undef { keyword_l, .. })
| Node::UnlessGuard(UnlessGuard { keyword_l, .. })
| Node::Until(Until { keyword_l, .. })
| Node::UntilPost(UntilPost { keyword_l, .. })
| Node::When(When { keyword_l, .. })
| Node::While(While { keyword_l, .. })
| Node::WhilePost(WhilePost { keyword_l, .. })
| Node::Yield(Yield { keyword_l, .. }) => Some(keyword_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support keyword_l loc", node.str_type())
}
}
}
fn get_name_l(node: &Node) -> Option<Loc> {
match node {
Node::Blockarg(Blockarg { name_l, .. })
| Node::Kwrestarg(Kwrestarg { name_l, .. })
| Node::Restarg(Restarg { name_l, .. }) => name_l.clone(),
Node::Casgn(Casgn { name_l, .. })
| Node::Const(Const { name_l, .. })
| Node::Cvasgn(Cvasgn { name_l, .. })
| Node::Def(Def { name_l, .. })
| Node::Defs(Defs { name_l, .. })
| Node::Gvasgn(Gvasgn { name_l, .. })
| Node::Ivasgn(Ivasgn { name_l, .. })
| Node::Kwarg(Kwarg { name_l, .. })
| Node::Kwnilarg(Kwnilarg { name_l, .. })
| Node::Kwoptarg(Kwoptarg { name_l, .. })
| Node::Lvasgn(Lvasgn { name_l, .. })
| Node::MatchNilPattern(MatchNilPattern { name_l, .. })
| Node::MatchVar(MatchVar { name_l, .. })
| Node::Optarg(Optarg { name_l, .. }) => Some(name_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support name_l loc", node.str_type())
}
}
}
fn get_assignment_l(node: &Node) -> Option<Loc> {
match node {
Node::Def(Def { assignment_l, .. })
| Node::Defs(Defs { assignment_l, .. }) => assignment_l.clone(),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support assignment_l loc", node.str_type())
}
}
}
fn get_colon_l(node: &Node) -> Option<Loc> {
match node {
Node::IfTernary(IfTernary { colon_l, .. }) => Some(colon_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support colon_l loc", node.str_type())
}
}
}
fn get_double_colon_l(node: &Node) -> Option<Loc> {
match node {
Node::Casgn(Casgn { double_colon_l, .. })
| Node::Const(Const { double_colon_l, .. }) => double_colon_l.clone(),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support double_colon_l loc", node.str_type())
}
}
}
fn get_else_l(node: &Node) -> Option<Loc> {
match node {
Node::Case(Case { else_l, .. })
| Node::CaseMatch(CaseMatch { else_l, .. })
| Node::If(If { else_l, .. })
| Node::Rescue(Rescue { else_l, .. }) => else_l.clone(),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support else_l loc", node.str_type())
}
}
}
fn get_heredoc_body_l(node: &Node) -> Option<Loc> {
match node {
Node::Heredoc(Heredoc { heredoc_body_l, .. })
| Node::XHeredoc(XHeredoc { heredoc_body_l, .. }) => Some(heredoc_body_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support heredoc_body_l loc", node.str_type())
}
}
}
fn get_operator_l(node: &Node) -> Option<Loc> {
match node {
Node::Casgn(Casgn { operator_l, .. })
| Node::Class(Class { operator_l, .. })
| Node::Complex(Complex { operator_l, .. })
| Node::CSend(CSend { operator_l, .. })
| Node::Cvasgn(Cvasgn { operator_l, .. })
| Node::Float(Float { operator_l, .. })
| Node::Gvasgn(Gvasgn { operator_l, .. })
| Node::IndexAsgn(IndexAsgn { operator_l, .. })
| Node::Int(Int { operator_l, .. })
| Node::Ivasgn(Ivasgn { operator_l, .. })
| Node::Lvasgn(Lvasgn { operator_l, .. })
| Node::Rational(Rational { operator_l, .. })
| Node::Send(Send { operator_l, .. }) => operator_l.clone(),
Node::And(And { operator_l, .. })
| Node::AndAsgn(AndAsgn { operator_l, .. })
| Node::Blockarg(Blockarg { operator_l, .. })
| Node::BlockPass(BlockPass { operator_l, .. })
| Node::Defs(Defs { operator_l, .. })
| Node::EFlipFlop(EFlipFlop { operator_l, .. })
| Node::Erange(Erange { operator_l, .. })
| Node::For(For { operator_l, .. })
| Node::IFlipFlop(IFlipFlop { operator_l, .. })
| Node::Irange(Irange { operator_l, .. })
| Node::Kwrestarg(Kwrestarg { operator_l, .. })
| Node::Kwsplat(Kwsplat { operator_l, .. })
| Node::Masgn(Masgn { operator_l, .. })
| Node::MatchAlt(MatchAlt { operator_l, .. })
| Node::MatchAs(MatchAs { operator_l, .. })
| Node::MatchNilPattern(MatchNilPattern { operator_l, .. })
| Node::MatchPattern(MatchPattern { operator_l, .. })
| Node::MatchPatternP(MatchPatternP { operator_l, .. })
| Node::MatchRest(MatchRest { operator_l, .. })
| Node::MatchWithLvasgn(MatchWithLvasgn { operator_l, .. })
| Node::OpAsgn(OpAsgn { operator_l, .. })
| Node::Optarg(Optarg { operator_l, .. })
| Node::Or(Or { operator_l, .. })
| Node::OrAsgn(OrAsgn { operator_l, .. })
| Node::Pair(Pair { operator_l, .. })
| Node::Restarg(Restarg { operator_l, .. })
| Node::SClass(SClass { operator_l, .. })
| Node::Splat(Splat { operator_l, .. }) => Some(operator_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support operator_l loc", node.str_type())
}
}
}
fn get_selector_l(node: &Node) -> Option<Loc> {
match node {
Node::CSend(CSend { selector_l, .. })
| Node::Send(Send { selector_l, .. }) => selector_l.clone(),
Node::Pin(Pin { selector_l, .. }) => Some(selector_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support selector_l loc", node.str_type())
}
}
}
fn get_assoc_l(node: &Node) -> Option<Loc> {
match node {
Node::RescueBody(RescueBody { assoc_l, .. }) => assoc_l.clone(),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support assoc_l loc", node.str_type())
}
}
}
fn get_question_l(node: &Node) -> Option<Loc> {
match node {
Node::IfTernary(IfTernary { question_l, .. }) => Some(question_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support question_l loc", node.str_type())
}
}
}
fn get_heredoc_end_l(node: &Node) -> Option<Loc> {
match node {
Node::Heredoc(Heredoc { heredoc_end_l, .. })
| Node::XHeredoc(XHeredoc { heredoc_end_l, .. }) => Some(heredoc_end_l.clone()),
#[allow(unreachable_patterns)]
_ => {
panic!("node {} doesn't support heredoc_end_l loc", node.str_type())
}
}
}
pub(crate) fn get(&self, node: &Node) -> Option<Loc> {
match self {
LocName::Begin => Self::get_begin_l(node),
LocName::End => Self::get_end_l(node),
LocName::Expression => Self::get_expression_l(node),
LocName::Keyword => Self::get_keyword_l(node),
LocName::Name => Self::get_name_l(node),
LocName::Assignment => Self::get_assignment_l(node),
LocName::Colon => Self::get_colon_l(node),
LocName::DoubleColon => Self::get_double_colon_l(node),
LocName::Else => Self::get_else_l(node),
LocName::HeredocBody => Self::get_heredoc_body_l(node),
LocName::Operator => Self::get_operator_l(node),
LocName::Selector => Self::get_selector_l(node),
LocName::Assoc => Self::get_assoc_l(node),
LocName::Question => Self::get_question_l(node),
LocName::HeredocEnd => Self::get_heredoc_end_l(node),
}
}
}