1use super::LocName;
4use crate::{Node, Loc};
5use crate::nodes::*;
6
7impl LocName {
8 fn get_begin_l(node: &Node) -> Option<Loc> {
9 match node {
10 Node::Args(Args { begin_l: loc, .. }) =>*loc,
11 Node::Array(Array { begin_l: loc, .. }) =>*loc,
12 Node::ArrayPattern(ArrayPattern { begin_l: loc, .. }) =>*loc,
13 Node::ArrayPatternWithTail(ArrayPatternWithTail { begin_l: loc, .. }) =>*loc,
14 Node::Begin(Begin { begin_l: loc, .. }) =>*loc,
15 Node::Block(Block { begin_l: loc, .. }) =>Some(*loc),
16 Node::ConstPattern(ConstPattern { begin_l: loc, .. }) =>Some(*loc),
17 Node::CSend(CSend { begin_l: loc, .. }) =>*loc,
18 Node::Defined(Defined { begin_l: loc, .. }) =>*loc,
19 Node::Dstr(Dstr { begin_l: loc, .. }) =>*loc,
20 Node::Dsym(Dsym { begin_l: loc, .. }) =>*loc,
21 Node::FindPattern(FindPattern { begin_l: loc, .. }) =>*loc,
22 Node::For(For { begin_l: loc, .. }) =>Some(*loc),
23 Node::Hash(Hash { begin_l: loc, .. }) =>*loc,
24 Node::HashPattern(HashPattern { begin_l: loc, .. }) =>*loc,
25 Node::If(If { begin_l: loc, .. }) =>Some(*loc),
26 Node::Index(Index { begin_l: loc, .. }) =>Some(*loc),
27 Node::IndexAsgn(IndexAsgn { begin_l: loc, .. }) =>Some(*loc),
28 Node::InPattern(InPattern { begin_l: loc, .. }) =>Some(*loc),
29 Node::KwBegin(KwBegin { begin_l: loc, .. }) =>*loc,
30 Node::Mlhs(Mlhs { begin_l: loc, .. }) =>*loc,
31 Node::Numblock(Numblock { begin_l: loc, .. }) =>Some(*loc),
32 Node::Postexe(Postexe { begin_l: loc, .. }) =>Some(*loc),
33 Node::Preexe(Preexe { begin_l: loc, .. }) =>Some(*loc),
34 Node::Procarg0(Procarg0 { begin_l: loc, .. }) =>*loc,
35 Node::Regexp(Regexp { begin_l: loc, .. }) =>Some(*loc),
36 Node::RescueBody(RescueBody { begin_l: loc, .. }) =>*loc,
37 Node::Send(Send { begin_l: loc, .. }) =>*loc,
38 Node::Str(Str { begin_l: loc, .. }) =>*loc,
39 Node::Super(Super { begin_l: loc, .. }) =>*loc,
40 Node::Sym(Sym { begin_l: loc, .. }) =>*loc,
41 Node::Until(Until { begin_l: loc, .. }) =>*loc,
42 Node::When(When { begin_l: loc, .. }) =>Some(*loc),
43 Node::While(While { begin_l: loc, .. }) =>*loc,
44 Node::Xstr(Xstr { begin_l: loc, .. }) =>Some(*loc),
45 Node::Yield(Yield { begin_l: loc, .. }) =>*loc,
46 #[allow(unreachable_patterns)]
47 _ => {
48 panic!("node {} doesn't support begin_l loc", node.str_type())
49 }
50 }
51 }
52 fn get_end_l(node: &Node) -> Option<Loc> {
53 match node {
54 Node::Args(Args { end_l: loc, .. }) =>*loc,
55 Node::Array(Array { end_l: loc, .. }) =>*loc,
56 Node::ArrayPattern(ArrayPattern { end_l: loc, .. }) =>*loc,
57 Node::ArrayPatternWithTail(ArrayPatternWithTail { end_l: loc, .. }) =>*loc,
58 Node::Begin(Begin { end_l: loc, .. }) =>*loc,
59 Node::Block(Block { end_l: loc, .. }) =>Some(*loc),
60 Node::Case(Case { end_l: loc, .. }) =>Some(*loc),
61 Node::CaseMatch(CaseMatch { end_l: loc, .. }) =>Some(*loc),
62 Node::Class(Class { end_l: loc, .. }) =>Some(*loc),
63 Node::ConstPattern(ConstPattern { end_l: loc, .. }) =>Some(*loc),
64 Node::CSend(CSend { end_l: loc, .. }) =>*loc,
65 Node::Def(Def { end_l: loc, .. }) =>*loc,
66 Node::Defined(Defined { end_l: loc, .. }) =>*loc,
67 Node::Defs(Defs { end_l: loc, .. }) =>*loc,
68 Node::Dstr(Dstr { end_l: loc, .. }) =>*loc,
69 Node::Dsym(Dsym { end_l: loc, .. }) =>*loc,
70 Node::FindPattern(FindPattern { end_l: loc, .. }) =>*loc,
71 Node::For(For { end_l: loc, .. }) =>Some(*loc),
72 Node::Hash(Hash { end_l: loc, .. }) =>*loc,
73 Node::HashPattern(HashPattern { end_l: loc, .. }) =>*loc,
74 Node::If(If { end_l: loc, .. }) =>*loc,
75 Node::Index(Index { end_l: loc, .. }) =>Some(*loc),
76 Node::IndexAsgn(IndexAsgn { end_l: loc, .. }) =>Some(*loc),
77 Node::KwBegin(KwBegin { end_l: loc, .. }) =>*loc,
78 Node::Mlhs(Mlhs { end_l: loc, .. }) =>*loc,
79 Node::Module(Module { end_l: loc, .. }) =>Some(*loc),
80 Node::Numblock(Numblock { end_l: loc, .. }) =>Some(*loc),
81 Node::Postexe(Postexe { end_l: loc, .. }) =>Some(*loc),
82 Node::Preexe(Preexe { end_l: loc, .. }) =>Some(*loc),
83 Node::Procarg0(Procarg0 { end_l: loc, .. }) =>*loc,
84 Node::Regexp(Regexp { end_l: loc, .. }) =>Some(*loc),
85 Node::SClass(SClass { end_l: loc, .. }) =>Some(*loc),
86 Node::Send(Send { end_l: loc, .. }) =>*loc,
87 Node::Str(Str { end_l: loc, .. }) =>*loc,
88 Node::Super(Super { end_l: loc, .. }) =>*loc,
89 Node::Sym(Sym { end_l: loc, .. }) =>*loc,
90 Node::Until(Until { end_l: loc, .. }) =>*loc,
91 Node::While(While { end_l: loc, .. }) =>*loc,
92 Node::Xstr(Xstr { end_l: loc, .. }) =>Some(*loc),
93 Node::Yield(Yield { end_l: loc, .. }) =>*loc,
94 #[allow(unreachable_patterns)]
95 _ => {
96 panic!("node {} doesn't support end_l loc", node.str_type())
97 }
98 }
99 }
100 fn get_expression_l(node: &Node) -> Option<Loc> {
101 match node {
102 Node::Alias(Alias { expression_l: loc, .. }) =>Some(*loc),
103 Node::And(And { expression_l: loc, .. }) =>Some(*loc),
104 Node::AndAsgn(AndAsgn { expression_l: loc, .. }) =>Some(*loc),
105 Node::Arg(Arg { expression_l: loc, .. }) =>Some(*loc),
106 Node::Args(Args { expression_l: loc, .. }) =>Some(*loc),
107 Node::Array(Array { expression_l: loc, .. }) =>Some(*loc),
108 Node::ArrayPattern(ArrayPattern { expression_l: loc, .. }) =>Some(*loc),
109 Node::ArrayPatternWithTail(ArrayPatternWithTail { expression_l: loc, .. }) =>Some(*loc),
110 Node::BackRef(BackRef { expression_l: loc, .. }) =>Some(*loc),
111 Node::Begin(Begin { expression_l: loc, .. }) =>Some(*loc),
112 Node::Block(Block { expression_l: loc, .. }) =>Some(*loc),
113 Node::Blockarg(Blockarg { expression_l: loc, .. }) =>Some(*loc),
114 Node::BlockPass(BlockPass { expression_l: loc, .. }) =>Some(*loc),
115 Node::Break(Break { expression_l: loc, .. }) =>Some(*loc),
116 Node::Case(Case { expression_l: loc, .. }) =>Some(*loc),
117 Node::CaseMatch(CaseMatch { expression_l: loc, .. }) =>Some(*loc),
118 Node::Casgn(Casgn { expression_l: loc, .. }) =>Some(*loc),
119 Node::Cbase(Cbase { expression_l: loc, .. }) =>Some(*loc),
120 Node::Class(Class { expression_l: loc, .. }) =>Some(*loc),
121 Node::Complex(Complex { expression_l: loc, .. }) =>Some(*loc),
122 Node::Const(Const { expression_l: loc, .. }) =>Some(*loc),
123 Node::ConstPattern(ConstPattern { expression_l: loc, .. }) =>Some(*loc),
124 Node::CSend(CSend { expression_l: loc, .. }) =>Some(*loc),
125 Node::Cvar(Cvar { expression_l: loc, .. }) =>Some(*loc),
126 Node::Cvasgn(Cvasgn { expression_l: loc, .. }) =>Some(*loc),
127 Node::Def(Def { expression_l: loc, .. }) =>Some(*loc),
128 Node::Defined(Defined { expression_l: loc, .. }) =>Some(*loc),
129 Node::Defs(Defs { expression_l: loc, .. }) =>Some(*loc),
130 Node::Dstr(Dstr { expression_l: loc, .. }) =>Some(*loc),
131 Node::Dsym(Dsym { expression_l: loc, .. }) =>Some(*loc),
132 Node::EFlipFlop(EFlipFlop { expression_l: loc, .. }) =>Some(*loc),
133 Node::EmptyElse(EmptyElse { expression_l: loc, .. }) =>Some(*loc),
134 Node::Encoding(Encoding { expression_l: loc, .. }) =>Some(*loc),
135 Node::Ensure(Ensure { expression_l: loc, .. }) =>Some(*loc),
136 Node::Erange(Erange { expression_l: loc, .. }) =>Some(*loc),
137 Node::False(False { expression_l: loc, .. }) =>Some(*loc),
138 Node::File(File { expression_l: loc, .. }) =>Some(*loc),
139 Node::FindPattern(FindPattern { expression_l: loc, .. }) =>Some(*loc),
140 Node::Float(Float { expression_l: loc, .. }) =>Some(*loc),
141 Node::For(For { expression_l: loc, .. }) =>Some(*loc),
142 Node::ForwardArg(ForwardArg { expression_l: loc, .. }) =>Some(*loc),
143 Node::ForwardedArgs(ForwardedArgs { expression_l: loc, .. }) =>Some(*loc),
144 Node::Gvar(Gvar { expression_l: loc, .. }) =>Some(*loc),
145 Node::Gvasgn(Gvasgn { expression_l: loc, .. }) =>Some(*loc),
146 Node::Hash(Hash { expression_l: loc, .. }) =>Some(*loc),
147 Node::HashPattern(HashPattern { expression_l: loc, .. }) =>Some(*loc),
148 Node::Heredoc(Heredoc { expression_l: loc, .. }) =>Some(*loc),
149 Node::If(If { expression_l: loc, .. }) =>Some(*loc),
150 Node::IfGuard(IfGuard { expression_l: loc, .. }) =>Some(*loc),
151 Node::IFlipFlop(IFlipFlop { expression_l: loc, .. }) =>Some(*loc),
152 Node::IfMod(IfMod { expression_l: loc, .. }) =>Some(*loc),
153 Node::IfTernary(IfTernary { expression_l: loc, .. }) =>Some(*loc),
154 Node::Index(Index { expression_l: loc, .. }) =>Some(*loc),
155 Node::IndexAsgn(IndexAsgn { expression_l: loc, .. }) =>Some(*loc),
156 Node::InPattern(InPattern { expression_l: loc, .. }) =>Some(*loc),
157 Node::Int(Int { expression_l: loc, .. }) =>Some(*loc),
158 Node::Irange(Irange { expression_l: loc, .. }) =>Some(*loc),
159 Node::Ivar(Ivar { expression_l: loc, .. }) =>Some(*loc),
160 Node::Ivasgn(Ivasgn { expression_l: loc, .. }) =>Some(*loc),
161 Node::Kwarg(Kwarg { expression_l: loc, .. }) =>Some(*loc),
162 Node::Kwargs(Kwargs { expression_l: loc, .. }) =>Some(*loc),
163 Node::KwBegin(KwBegin { expression_l: loc, .. }) =>Some(*loc),
164 Node::Kwnilarg(Kwnilarg { expression_l: loc, .. }) =>Some(*loc),
165 Node::Kwoptarg(Kwoptarg { expression_l: loc, .. }) =>Some(*loc),
166 Node::Kwrestarg(Kwrestarg { expression_l: loc, .. }) =>Some(*loc),
167 Node::Kwsplat(Kwsplat { expression_l: loc, .. }) =>Some(*loc),
168 Node::Lambda(Lambda { expression_l: loc, .. }) =>Some(*loc),
169 Node::Line(Line { expression_l: loc, .. }) =>Some(*loc),
170 Node::Lvar(Lvar { expression_l: loc, .. }) =>Some(*loc),
171 Node::Lvasgn(Lvasgn { expression_l: loc, .. }) =>Some(*loc),
172 Node::Masgn(Masgn { expression_l: loc, .. }) =>Some(*loc),
173 Node::MatchAlt(MatchAlt { expression_l: loc, .. }) =>Some(*loc),
174 Node::MatchAs(MatchAs { expression_l: loc, .. }) =>Some(*loc),
175 Node::MatchCurrentLine(MatchCurrentLine { expression_l: loc, .. }) =>Some(*loc),
176 Node::MatchNilPattern(MatchNilPattern { expression_l: loc, .. }) =>Some(*loc),
177 Node::MatchPattern(MatchPattern { expression_l: loc, .. }) =>Some(*loc),
178 Node::MatchPatternP(MatchPatternP { expression_l: loc, .. }) =>Some(*loc),
179 Node::MatchRest(MatchRest { expression_l: loc, .. }) =>Some(*loc),
180 Node::MatchVar(MatchVar { expression_l: loc, .. }) =>Some(*loc),
181 Node::MatchWithLvasgn(MatchWithLvasgn { expression_l: loc, .. }) =>Some(*loc),
182 Node::Mlhs(Mlhs { expression_l: loc, .. }) =>Some(*loc),
183 Node::Module(Module { expression_l: loc, .. }) =>Some(*loc),
184 Node::Next(Next { expression_l: loc, .. }) =>Some(*loc),
185 Node::Nil(Nil { expression_l: loc, .. }) =>Some(*loc),
186 Node::NthRef(NthRef { expression_l: loc, .. }) =>Some(*loc),
187 Node::Numblock(Numblock { expression_l: loc, .. }) =>Some(*loc),
188 Node::OpAsgn(OpAsgn { expression_l: loc, .. }) =>Some(*loc),
189 Node::Optarg(Optarg { expression_l: loc, .. }) =>Some(*loc),
190 Node::Or(Or { expression_l: loc, .. }) =>Some(*loc),
191 Node::OrAsgn(OrAsgn { expression_l: loc, .. }) =>Some(*loc),
192 Node::Pair(Pair { expression_l: loc, .. }) =>Some(*loc),
193 Node::Pin(Pin { expression_l: loc, .. }) =>Some(*loc),
194 Node::Postexe(Postexe { expression_l: loc, .. }) =>Some(*loc),
195 Node::Preexe(Preexe { expression_l: loc, .. }) =>Some(*loc),
196 Node::Procarg0(Procarg0 { expression_l: loc, .. }) =>Some(*loc),
197 Node::Rational(Rational { expression_l: loc, .. }) =>Some(*loc),
198 Node::Redo(Redo { expression_l: loc, .. }) =>Some(*loc),
199 Node::Regexp(Regexp { expression_l: loc, .. }) =>Some(*loc),
200 Node::RegOpt(RegOpt { expression_l: loc, .. }) =>Some(*loc),
201 Node::Rescue(Rescue { expression_l: loc, .. }) =>Some(*loc),
202 Node::RescueBody(RescueBody { expression_l: loc, .. }) =>Some(*loc),
203 Node::Restarg(Restarg { expression_l: loc, .. }) =>Some(*loc),
204 Node::Retry(Retry { expression_l: loc, .. }) =>Some(*loc),
205 Node::Return(Return { expression_l: loc, .. }) =>Some(*loc),
206 Node::SClass(SClass { expression_l: loc, .. }) =>Some(*loc),
207 Node::Self_(Self_ { expression_l: loc, .. }) =>Some(*loc),
208 Node::Send(Send { expression_l: loc, .. }) =>Some(*loc),
209 Node::Shadowarg(Shadowarg { expression_l: loc, .. }) =>Some(*loc),
210 Node::Splat(Splat { expression_l: loc, .. }) =>Some(*loc),
211 Node::Str(Str { expression_l: loc, .. }) =>Some(*loc),
212 Node::Super(Super { expression_l: loc, .. }) =>Some(*loc),
213 Node::Sym(Sym { expression_l: loc, .. }) =>Some(*loc),
214 Node::True(True { expression_l: loc, .. }) =>Some(*loc),
215 Node::Undef(Undef { expression_l: loc, .. }) =>Some(*loc),
216 Node::UnlessGuard(UnlessGuard { expression_l: loc, .. }) =>Some(*loc),
217 Node::Until(Until { expression_l: loc, .. }) =>Some(*loc),
218 Node::UntilPost(UntilPost { expression_l: loc, .. }) =>Some(*loc),
219 Node::When(When { expression_l: loc, .. }) =>Some(*loc),
220 Node::While(While { expression_l: loc, .. }) =>Some(*loc),
221 Node::WhilePost(WhilePost { expression_l: loc, .. }) =>Some(*loc),
222 Node::XHeredoc(XHeredoc { expression_l: loc, .. }) =>Some(*loc),
223 Node::Xstr(Xstr { expression_l: loc, .. }) =>Some(*loc),
224 Node::Yield(Yield { expression_l: loc, .. }) =>Some(*loc),
225 Node::ZSuper(ZSuper { expression_l: loc, .. }) =>Some(*loc),
226 #[allow(unreachable_patterns)]
227 _ => {
228 panic!("node {} doesn't support expression_l loc", node.str_type())
229 }
230 }
231 }
232 fn get_keyword_l(node: &Node) -> Option<Loc> {
233 match node {
234 Node::Alias(Alias { keyword_l: loc, .. }) =>Some(*loc),
235 Node::Break(Break { keyword_l: loc, .. }) =>Some(*loc),
236 Node::Case(Case { keyword_l: loc, .. }) =>Some(*loc),
237 Node::CaseMatch(CaseMatch { keyword_l: loc, .. }) =>Some(*loc),
238 Node::Class(Class { keyword_l: loc, .. }) =>Some(*loc),
239 Node::Def(Def { keyword_l: loc, .. }) =>Some(*loc),
240 Node::Defined(Defined { keyword_l: loc, .. }) =>Some(*loc),
241 Node::Defs(Defs { keyword_l: loc, .. }) =>Some(*loc),
242 Node::Ensure(Ensure { keyword_l: loc, .. }) =>Some(*loc),
243 Node::For(For { keyword_l: loc, .. }) =>Some(*loc),
244 Node::If(If { keyword_l: loc, .. }) =>Some(*loc),
245 Node::IfGuard(IfGuard { keyword_l: loc, .. }) =>Some(*loc),
246 Node::IfMod(IfMod { keyword_l: loc, .. }) =>Some(*loc),
247 Node::InPattern(InPattern { keyword_l: loc, .. }) =>Some(*loc),
248 Node::Module(Module { keyword_l: loc, .. }) =>Some(*loc),
249 Node::Next(Next { keyword_l: loc, .. }) =>Some(*loc),
250 Node::Postexe(Postexe { keyword_l: loc, .. }) =>Some(*loc),
251 Node::Preexe(Preexe { keyword_l: loc, .. }) =>Some(*loc),
252 Node::RescueBody(RescueBody { keyword_l: loc, .. }) =>Some(*loc),
253 Node::Return(Return { keyword_l: loc, .. }) =>Some(*loc),
254 Node::SClass(SClass { keyword_l: loc, .. }) =>Some(*loc),
255 Node::Super(Super { keyword_l: loc, .. }) =>Some(*loc),
256 Node::Undef(Undef { keyword_l: loc, .. }) =>Some(*loc),
257 Node::UnlessGuard(UnlessGuard { keyword_l: loc, .. }) =>Some(*loc),
258 Node::Until(Until { keyword_l: loc, .. }) =>Some(*loc),
259 Node::UntilPost(UntilPost { keyword_l: loc, .. }) =>Some(*loc),
260 Node::When(When { keyword_l: loc, .. }) =>Some(*loc),
261 Node::While(While { keyword_l: loc, .. }) =>Some(*loc),
262 Node::WhilePost(WhilePost { keyword_l: loc, .. }) =>Some(*loc),
263 Node::Yield(Yield { keyword_l: loc, .. }) =>Some(*loc),
264 #[allow(unreachable_patterns)]
265 _ => {
266 panic!("node {} doesn't support keyword_l loc", node.str_type())
267 }
268 }
269 }
270 fn get_name_l(node: &Node) -> Option<Loc> {
271 match node {
272 Node::Blockarg(Blockarg { name_l: loc, .. }) =>*loc,
273 Node::Casgn(Casgn { name_l: loc, .. }) =>Some(*loc),
274 Node::Const(Const { name_l: loc, .. }) =>Some(*loc),
275 Node::Cvasgn(Cvasgn { name_l: loc, .. }) =>Some(*loc),
276 Node::Def(Def { name_l: loc, .. }) =>Some(*loc),
277 Node::Defs(Defs { name_l: loc, .. }) =>Some(*loc),
278 Node::Gvasgn(Gvasgn { name_l: loc, .. }) =>Some(*loc),
279 Node::Ivasgn(Ivasgn { name_l: loc, .. }) =>Some(*loc),
280 Node::Kwarg(Kwarg { name_l: loc, .. }) =>Some(*loc),
281 Node::Kwnilarg(Kwnilarg { name_l: loc, .. }) =>Some(*loc),
282 Node::Kwoptarg(Kwoptarg { name_l: loc, .. }) =>Some(*loc),
283 Node::Kwrestarg(Kwrestarg { name_l: loc, .. }) =>*loc,
284 Node::Lvasgn(Lvasgn { name_l: loc, .. }) =>Some(*loc),
285 Node::MatchNilPattern(MatchNilPattern { name_l: loc, .. }) =>Some(*loc),
286 Node::MatchVar(MatchVar { name_l: loc, .. }) =>Some(*loc),
287 Node::Optarg(Optarg { name_l: loc, .. }) =>Some(*loc),
288 Node::Restarg(Restarg { name_l: loc, .. }) =>*loc,
289 #[allow(unreachable_patterns)]
290 _ => {
291 panic!("node {} doesn't support name_l loc", node.str_type())
292 }
293 }
294 }
295 fn get_assignment_l(node: &Node) -> Option<Loc> {
296 match node {
297 Node::Def(Def { assignment_l: loc, .. }) =>*loc,
298 Node::Defs(Defs { assignment_l: loc, .. }) =>*loc,
299 #[allow(unreachable_patterns)]
300 _ => {
301 panic!("node {} doesn't support assignment_l loc", node.str_type())
302 }
303 }
304 }
305 fn get_colon_l(node: &Node) -> Option<Loc> {
306 match node {
307 Node::IfTernary(IfTernary { colon_l: loc, .. }) =>Some(*loc),
308 #[allow(unreachable_patterns)]
309 _ => {
310 panic!("node {} doesn't support colon_l loc", node.str_type())
311 }
312 }
313 }
314 fn get_double_colon_l(node: &Node) -> Option<Loc> {
315 match node {
316 Node::Casgn(Casgn { double_colon_l: loc, .. }) =>*loc,
317 Node::Const(Const { double_colon_l: loc, .. }) =>*loc,
318 #[allow(unreachable_patterns)]
319 _ => {
320 panic!("node {} doesn't support double_colon_l loc", node.str_type())
321 }
322 }
323 }
324 fn get_else_l(node: &Node) -> Option<Loc> {
325 match node {
326 Node::Case(Case { else_l: loc, .. }) =>*loc,
327 Node::CaseMatch(CaseMatch { else_l: loc, .. }) =>*loc,
328 Node::If(If { else_l: loc, .. }) =>*loc,
329 Node::Rescue(Rescue { else_l: loc, .. }) =>*loc,
330 #[allow(unreachable_patterns)]
331 _ => {
332 panic!("node {} doesn't support else_l loc", node.str_type())
333 }
334 }
335 }
336 fn get_heredoc_body_l(node: &Node) -> Option<Loc> {
337 match node {
338 Node::Heredoc(Heredoc { heredoc_body_l: loc, .. }) =>Some(*loc),
339 Node::XHeredoc(XHeredoc { heredoc_body_l: loc, .. }) =>Some(*loc),
340 #[allow(unreachable_patterns)]
341 _ => {
342 panic!("node {} doesn't support heredoc_body_l loc", node.str_type())
343 }
344 }
345 }
346 fn get_operator_l(node: &Node) -> Option<Loc> {
347 match node {
348 Node::And(And { operator_l: loc, .. }) =>Some(*loc),
349 Node::AndAsgn(AndAsgn { operator_l: loc, .. }) =>Some(*loc),
350 Node::Blockarg(Blockarg { operator_l: loc, .. }) =>Some(*loc),
351 Node::BlockPass(BlockPass { operator_l: loc, .. }) =>Some(*loc),
352 Node::Casgn(Casgn { operator_l: loc, .. }) =>*loc,
353 Node::Class(Class { operator_l: loc, .. }) =>*loc,
354 Node::Complex(Complex { operator_l: loc, .. }) =>*loc,
355 Node::CSend(CSend { operator_l: loc, .. }) =>*loc,
356 Node::Cvasgn(Cvasgn { operator_l: loc, .. }) =>*loc,
357 Node::Defs(Defs { operator_l: loc, .. }) =>Some(*loc),
358 Node::EFlipFlop(EFlipFlop { operator_l: loc, .. }) =>Some(*loc),
359 Node::Erange(Erange { operator_l: loc, .. }) =>Some(*loc),
360 Node::Float(Float { operator_l: loc, .. }) =>*loc,
361 Node::For(For { operator_l: loc, .. }) =>Some(*loc),
362 Node::Gvasgn(Gvasgn { operator_l: loc, .. }) =>*loc,
363 Node::IFlipFlop(IFlipFlop { operator_l: loc, .. }) =>Some(*loc),
364 Node::IndexAsgn(IndexAsgn { operator_l: loc, .. }) =>*loc,
365 Node::Int(Int { operator_l: loc, .. }) =>*loc,
366 Node::Irange(Irange { operator_l: loc, .. }) =>Some(*loc),
367 Node::Ivasgn(Ivasgn { operator_l: loc, .. }) =>*loc,
368 Node::Kwrestarg(Kwrestarg { operator_l: loc, .. }) =>Some(*loc),
369 Node::Kwsplat(Kwsplat { operator_l: loc, .. }) =>Some(*loc),
370 Node::Lvasgn(Lvasgn { operator_l: loc, .. }) =>*loc,
371 Node::Masgn(Masgn { operator_l: loc, .. }) =>Some(*loc),
372 Node::MatchAlt(MatchAlt { operator_l: loc, .. }) =>Some(*loc),
373 Node::MatchAs(MatchAs { operator_l: loc, .. }) =>Some(*loc),
374 Node::MatchNilPattern(MatchNilPattern { operator_l: loc, .. }) =>Some(*loc),
375 Node::MatchPattern(MatchPattern { operator_l: loc, .. }) =>Some(*loc),
376 Node::MatchPatternP(MatchPatternP { operator_l: loc, .. }) =>Some(*loc),
377 Node::MatchRest(MatchRest { operator_l: loc, .. }) =>Some(*loc),
378 Node::MatchWithLvasgn(MatchWithLvasgn { operator_l: loc, .. }) =>Some(*loc),
379 Node::OpAsgn(OpAsgn { operator_l: loc, .. }) =>Some(*loc),
380 Node::Optarg(Optarg { operator_l: loc, .. }) =>Some(*loc),
381 Node::Or(Or { operator_l: loc, .. }) =>Some(*loc),
382 Node::OrAsgn(OrAsgn { operator_l: loc, .. }) =>Some(*loc),
383 Node::Pair(Pair { operator_l: loc, .. }) =>Some(*loc),
384 Node::Rational(Rational { operator_l: loc, .. }) =>*loc,
385 Node::Restarg(Restarg { operator_l: loc, .. }) =>Some(*loc),
386 Node::SClass(SClass { operator_l: loc, .. }) =>Some(*loc),
387 Node::Send(Send { operator_l: loc, .. }) =>*loc,
388 Node::Splat(Splat { operator_l: loc, .. }) =>Some(*loc),
389 #[allow(unreachable_patterns)]
390 _ => {
391 panic!("node {} doesn't support operator_l loc", node.str_type())
392 }
393 }
394 }
395 fn get_selector_l(node: &Node) -> Option<Loc> {
396 match node {
397 Node::CSend(CSend { selector_l: loc, .. }) =>*loc,
398 Node::Pin(Pin { selector_l: loc, .. }) =>Some(*loc),
399 Node::Send(Send { selector_l: loc, .. }) =>*loc,
400 #[allow(unreachable_patterns)]
401 _ => {
402 panic!("node {} doesn't support selector_l loc", node.str_type())
403 }
404 }
405 }
406 fn get_assoc_l(node: &Node) -> Option<Loc> {
407 match node {
408 Node::RescueBody(RescueBody { assoc_l: loc, .. }) =>*loc,
409 #[allow(unreachable_patterns)]
410 _ => {
411 panic!("node {} doesn't support assoc_l loc", node.str_type())
412 }
413 }
414 }
415 fn get_question_l(node: &Node) -> Option<Loc> {
416 match node {
417 Node::IfTernary(IfTernary { question_l: loc, .. }) =>Some(*loc),
418 #[allow(unreachable_patterns)]
419 _ => {
420 panic!("node {} doesn't support question_l loc", node.str_type())
421 }
422 }
423 }
424 fn get_heredoc_end_l(node: &Node) -> Option<Loc> {
425 match node {
426 Node::Heredoc(Heredoc { heredoc_end_l: loc, .. }) =>Some(*loc),
427 Node::XHeredoc(XHeredoc { heredoc_end_l: loc, .. }) =>Some(*loc),
428 #[allow(unreachable_patterns)]
429 _ => {
430 panic!("node {} doesn't support heredoc_end_l loc", node.str_type())
431 }
432 }
433 }
434
435
436 pub fn get(&self, node: &Node) -> Option<Loc> {
437 match self {
438 Self::Begin => Self::get_begin_l(node),
439 Self::End => Self::get_end_l(node),
440 Self::Expression => Self::get_expression_l(node),
441 Self::Keyword => Self::get_keyword_l(node),
442 Self::Name => Self::get_name_l(node),
443 Self::Assignment => Self::get_assignment_l(node),
444 Self::Colon => Self::get_colon_l(node),
445 Self::DoubleColon => Self::get_double_colon_l(node),
446 Self::Else => Self::get_else_l(node),
447 Self::HeredocBody => Self::get_heredoc_body_l(node),
448 Self::Operator => Self::get_operator_l(node),
449 Self::Selector => Self::get_selector_l(node),
450 Self::Assoc => Self::get_assoc_l(node),
451 Self::Question => Self::get_question_l(node),
452 Self::HeredocEnd => Self::get_heredoc_end_l(node),
453
454 }
455 }
456}