1pub type Mod = crate::generic::Mod<SourceRange>;
4
5pub type ModModule = crate::generic::ModModule<SourceRange>;
6
7#[cfg(feature = "all-nodes-with-ranges")]
8impl Located for ModModule {
9 fn range(&self) -> SourceRange {
10 self.range
11 }
12}
13#[cfg(feature = "all-nodes-with-ranges")]
14impl LocatedMut for ModModule {
15 fn range_mut(&mut self) -> &mut SourceRange {
16 &mut self.range
17 }
18}
19
20pub type ModInteractive = crate::generic::ModInteractive<SourceRange>;
21
22#[cfg(feature = "all-nodes-with-ranges")]
23impl Located for ModInteractive {
24 fn range(&self) -> SourceRange {
25 self.range
26 }
27}
28#[cfg(feature = "all-nodes-with-ranges")]
29impl LocatedMut for ModInteractive {
30 fn range_mut(&mut self) -> &mut SourceRange {
31 &mut self.range
32 }
33}
34
35pub type ModExpression = crate::generic::ModExpression<SourceRange>;
36
37#[cfg(feature = "all-nodes-with-ranges")]
38impl Located for ModExpression {
39 fn range(&self) -> SourceRange {
40 self.range
41 }
42}
43#[cfg(feature = "all-nodes-with-ranges")]
44impl LocatedMut for ModExpression {
45 fn range_mut(&mut self) -> &mut SourceRange {
46 &mut self.range
47 }
48}
49
50pub type ModFunctionType = crate::generic::ModFunctionType<SourceRange>;
51
52#[cfg(feature = "all-nodes-with-ranges")]
53impl Located for ModFunctionType {
54 fn range(&self) -> SourceRange {
55 self.range
56 }
57}
58#[cfg(feature = "all-nodes-with-ranges")]
59impl LocatedMut for ModFunctionType {
60 fn range_mut(&mut self) -> &mut SourceRange {
61 &mut self.range
62 }
63}
64
65#[cfg(feature = "all-nodes-with-ranges")]
66impl Located for Mod {
67 fn range(&self) -> SourceRange {
68 match self {
69 Self::Module(node) => node.range(),
70 Self::Interactive(node) => node.range(),
71 Self::Expression(node) => node.range(),
72 Self::FunctionType(node) => node.range(),
73 }
74 }
75}
76#[cfg(feature = "all-nodes-with-ranges")]
77impl LocatedMut for Mod {
78 fn range_mut(&mut self) -> &mut SourceRange {
79 match self {
80 Self::Module(node) => node.range_mut(),
81 Self::Interactive(node) => node.range_mut(),
82 Self::Expression(node) => node.range_mut(),
83 Self::FunctionType(node) => node.range_mut(),
84 }
85 }
86}
87
88pub type Stmt = crate::generic::Stmt<SourceRange>;
89
90pub type StmtFunctionDef = crate::generic::StmtFunctionDef<SourceRange>;
91
92impl Located for StmtFunctionDef {
93 fn range(&self) -> SourceRange {
94 self.range
95 }
96}
97
98impl LocatedMut for StmtFunctionDef {
99 fn range_mut(&mut self) -> &mut SourceRange {
100 &mut self.range
101 }
102}
103
104pub type StmtAsyncFunctionDef = crate::generic::StmtAsyncFunctionDef<SourceRange>;
105
106impl Located for StmtAsyncFunctionDef {
107 fn range(&self) -> SourceRange {
108 self.range
109 }
110}
111
112impl LocatedMut for StmtAsyncFunctionDef {
113 fn range_mut(&mut self) -> &mut SourceRange {
114 &mut self.range
115 }
116}
117
118pub type StmtClassDef = crate::generic::StmtClassDef<SourceRange>;
119
120impl Located for StmtClassDef {
121 fn range(&self) -> SourceRange {
122 self.range
123 }
124}
125
126impl LocatedMut for StmtClassDef {
127 fn range_mut(&mut self) -> &mut SourceRange {
128 &mut self.range
129 }
130}
131
132pub type StmtReturn = crate::generic::StmtReturn<SourceRange>;
133
134impl Located for StmtReturn {
135 fn range(&self) -> SourceRange {
136 self.range
137 }
138}
139
140impl LocatedMut for StmtReturn {
141 fn range_mut(&mut self) -> &mut SourceRange {
142 &mut self.range
143 }
144}
145
146pub type StmtDelete = crate::generic::StmtDelete<SourceRange>;
147
148impl Located for StmtDelete {
149 fn range(&self) -> SourceRange {
150 self.range
151 }
152}
153
154impl LocatedMut for StmtDelete {
155 fn range_mut(&mut self) -> &mut SourceRange {
156 &mut self.range
157 }
158}
159
160pub type StmtAssign = crate::generic::StmtAssign<SourceRange>;
161
162impl Located for StmtAssign {
163 fn range(&self) -> SourceRange {
164 self.range
165 }
166}
167
168impl LocatedMut for StmtAssign {
169 fn range_mut(&mut self) -> &mut SourceRange {
170 &mut self.range
171 }
172}
173
174pub type StmtTypeAlias = crate::generic::StmtTypeAlias<SourceRange>;
175
176impl Located for StmtTypeAlias {
177 fn range(&self) -> SourceRange {
178 self.range
179 }
180}
181
182impl LocatedMut for StmtTypeAlias {
183 fn range_mut(&mut self) -> &mut SourceRange {
184 &mut self.range
185 }
186}
187
188pub type StmtAugAssign = crate::generic::StmtAugAssign<SourceRange>;
189
190impl Located for StmtAugAssign {
191 fn range(&self) -> SourceRange {
192 self.range
193 }
194}
195
196impl LocatedMut for StmtAugAssign {
197 fn range_mut(&mut self) -> &mut SourceRange {
198 &mut self.range
199 }
200}
201
202pub type StmtAnnAssign = crate::generic::StmtAnnAssign<SourceRange>;
203
204impl Located for StmtAnnAssign {
205 fn range(&self) -> SourceRange {
206 self.range
207 }
208}
209
210impl LocatedMut for StmtAnnAssign {
211 fn range_mut(&mut self) -> &mut SourceRange {
212 &mut self.range
213 }
214}
215
216pub type StmtFor = crate::generic::StmtFor<SourceRange>;
217
218impl Located for StmtFor {
219 fn range(&self) -> SourceRange {
220 self.range
221 }
222}
223
224impl LocatedMut for StmtFor {
225 fn range_mut(&mut self) -> &mut SourceRange {
226 &mut self.range
227 }
228}
229
230pub type StmtAsyncFor = crate::generic::StmtAsyncFor<SourceRange>;
231
232impl Located for StmtAsyncFor {
233 fn range(&self) -> SourceRange {
234 self.range
235 }
236}
237
238impl LocatedMut for StmtAsyncFor {
239 fn range_mut(&mut self) -> &mut SourceRange {
240 &mut self.range
241 }
242}
243
244pub type StmtWhile = crate::generic::StmtWhile<SourceRange>;
245
246impl Located for StmtWhile {
247 fn range(&self) -> SourceRange {
248 self.range
249 }
250}
251
252impl LocatedMut for StmtWhile {
253 fn range_mut(&mut self) -> &mut SourceRange {
254 &mut self.range
255 }
256}
257
258pub type StmtIf = crate::generic::StmtIf<SourceRange>;
259
260impl Located for StmtIf {
261 fn range(&self) -> SourceRange {
262 self.range
263 }
264}
265
266impl LocatedMut for StmtIf {
267 fn range_mut(&mut self) -> &mut SourceRange {
268 &mut self.range
269 }
270}
271
272pub type StmtWith = crate::generic::StmtWith<SourceRange>;
273
274impl Located for StmtWith {
275 fn range(&self) -> SourceRange {
276 self.range
277 }
278}
279
280impl LocatedMut for StmtWith {
281 fn range_mut(&mut self) -> &mut SourceRange {
282 &mut self.range
283 }
284}
285
286pub type StmtAsyncWith = crate::generic::StmtAsyncWith<SourceRange>;
287
288impl Located for StmtAsyncWith {
289 fn range(&self) -> SourceRange {
290 self.range
291 }
292}
293
294impl LocatedMut for StmtAsyncWith {
295 fn range_mut(&mut self) -> &mut SourceRange {
296 &mut self.range
297 }
298}
299
300pub type StmtMatch = crate::generic::StmtMatch<SourceRange>;
301
302impl Located for StmtMatch {
303 fn range(&self) -> SourceRange {
304 self.range
305 }
306}
307
308impl LocatedMut for StmtMatch {
309 fn range_mut(&mut self) -> &mut SourceRange {
310 &mut self.range
311 }
312}
313
314pub type StmtRaise = crate::generic::StmtRaise<SourceRange>;
315
316impl Located for StmtRaise {
317 fn range(&self) -> SourceRange {
318 self.range
319 }
320}
321
322impl LocatedMut for StmtRaise {
323 fn range_mut(&mut self) -> &mut SourceRange {
324 &mut self.range
325 }
326}
327
328pub type StmtTry = crate::generic::StmtTry<SourceRange>;
329
330impl Located for StmtTry {
331 fn range(&self) -> SourceRange {
332 self.range
333 }
334}
335
336impl LocatedMut for StmtTry {
337 fn range_mut(&mut self) -> &mut SourceRange {
338 &mut self.range
339 }
340}
341
342pub type StmtTryStar = crate::generic::StmtTryStar<SourceRange>;
343
344impl Located for StmtTryStar {
345 fn range(&self) -> SourceRange {
346 self.range
347 }
348}
349
350impl LocatedMut for StmtTryStar {
351 fn range_mut(&mut self) -> &mut SourceRange {
352 &mut self.range
353 }
354}
355
356pub type StmtAssert = crate::generic::StmtAssert<SourceRange>;
357
358impl Located for StmtAssert {
359 fn range(&self) -> SourceRange {
360 self.range
361 }
362}
363
364impl LocatedMut for StmtAssert {
365 fn range_mut(&mut self) -> &mut SourceRange {
366 &mut self.range
367 }
368}
369
370pub type StmtImport = crate::generic::StmtImport<SourceRange>;
371
372impl Located for StmtImport {
373 fn range(&self) -> SourceRange {
374 self.range
375 }
376}
377
378impl LocatedMut for StmtImport {
379 fn range_mut(&mut self) -> &mut SourceRange {
380 &mut self.range
381 }
382}
383
384pub type StmtImportFrom = crate::generic::StmtImportFrom<SourceRange>;
385
386impl Located for StmtImportFrom {
387 fn range(&self) -> SourceRange {
388 self.range
389 }
390}
391
392impl LocatedMut for StmtImportFrom {
393 fn range_mut(&mut self) -> &mut SourceRange {
394 &mut self.range
395 }
396}
397
398pub type StmtGlobal = crate::generic::StmtGlobal<SourceRange>;
399
400impl Located for StmtGlobal {
401 fn range(&self) -> SourceRange {
402 self.range
403 }
404}
405
406impl LocatedMut for StmtGlobal {
407 fn range_mut(&mut self) -> &mut SourceRange {
408 &mut self.range
409 }
410}
411
412pub type StmtNonlocal = crate::generic::StmtNonlocal<SourceRange>;
413
414impl Located for StmtNonlocal {
415 fn range(&self) -> SourceRange {
416 self.range
417 }
418}
419
420impl LocatedMut for StmtNonlocal {
421 fn range_mut(&mut self) -> &mut SourceRange {
422 &mut self.range
423 }
424}
425
426pub type StmtExpr = crate::generic::StmtExpr<SourceRange>;
427
428impl Located for StmtExpr {
429 fn range(&self) -> SourceRange {
430 self.range
431 }
432}
433
434impl LocatedMut for StmtExpr {
435 fn range_mut(&mut self) -> &mut SourceRange {
436 &mut self.range
437 }
438}
439
440pub type StmtPass = crate::generic::StmtPass<SourceRange>;
441
442impl Located for StmtPass {
443 fn range(&self) -> SourceRange {
444 self.range
445 }
446}
447
448impl LocatedMut for StmtPass {
449 fn range_mut(&mut self) -> &mut SourceRange {
450 &mut self.range
451 }
452}
453
454pub type StmtBreak = crate::generic::StmtBreak<SourceRange>;
455
456impl Located for StmtBreak {
457 fn range(&self) -> SourceRange {
458 self.range
459 }
460}
461
462impl LocatedMut for StmtBreak {
463 fn range_mut(&mut self) -> &mut SourceRange {
464 &mut self.range
465 }
466}
467
468pub type StmtContinue = crate::generic::StmtContinue<SourceRange>;
469
470impl Located for StmtContinue {
471 fn range(&self) -> SourceRange {
472 self.range
473 }
474}
475
476impl LocatedMut for StmtContinue {
477 fn range_mut(&mut self) -> &mut SourceRange {
478 &mut self.range
479 }
480}
481
482impl Located for Stmt {
483 fn range(&self) -> SourceRange {
484 match self {
485 Self::FunctionDef(node) => node.range(),
486 Self::AsyncFunctionDef(node) => node.range(),
487 Self::ClassDef(node) => node.range(),
488 Self::Return(node) => node.range(),
489 Self::Delete(node) => node.range(),
490 Self::Assign(node) => node.range(),
491 Self::TypeAlias(node) => node.range(),
492 Self::AugAssign(node) => node.range(),
493 Self::AnnAssign(node) => node.range(),
494 Self::For(node) => node.range(),
495 Self::AsyncFor(node) => node.range(),
496 Self::While(node) => node.range(),
497 Self::If(node) => node.range(),
498 Self::With(node) => node.range(),
499 Self::AsyncWith(node) => node.range(),
500 Self::Match(node) => node.range(),
501 Self::Raise(node) => node.range(),
502 Self::Try(node) => node.range(),
503 Self::TryStar(node) => node.range(),
504 Self::Assert(node) => node.range(),
505 Self::Import(node) => node.range(),
506 Self::ImportFrom(node) => node.range(),
507 Self::Global(node) => node.range(),
508 Self::Nonlocal(node) => node.range(),
509 Self::Expr(node) => node.range(),
510 Self::Pass(node) => node.range(),
511 Self::Break(node) => node.range(),
512 Self::Continue(node) => node.range(),
513 }
514 }
515}
516
517impl LocatedMut for Stmt {
518 fn range_mut(&mut self) -> &mut SourceRange {
519 match self {
520 Self::FunctionDef(node) => node.range_mut(),
521 Self::AsyncFunctionDef(node) => node.range_mut(),
522 Self::ClassDef(node) => node.range_mut(),
523 Self::Return(node) => node.range_mut(),
524 Self::Delete(node) => node.range_mut(),
525 Self::Assign(node) => node.range_mut(),
526 Self::TypeAlias(node) => node.range_mut(),
527 Self::AugAssign(node) => node.range_mut(),
528 Self::AnnAssign(node) => node.range_mut(),
529 Self::For(node) => node.range_mut(),
530 Self::AsyncFor(node) => node.range_mut(),
531 Self::While(node) => node.range_mut(),
532 Self::If(node) => node.range_mut(),
533 Self::With(node) => node.range_mut(),
534 Self::AsyncWith(node) => node.range_mut(),
535 Self::Match(node) => node.range_mut(),
536 Self::Raise(node) => node.range_mut(),
537 Self::Try(node) => node.range_mut(),
538 Self::TryStar(node) => node.range_mut(),
539 Self::Assert(node) => node.range_mut(),
540 Self::Import(node) => node.range_mut(),
541 Self::ImportFrom(node) => node.range_mut(),
542 Self::Global(node) => node.range_mut(),
543 Self::Nonlocal(node) => node.range_mut(),
544 Self::Expr(node) => node.range_mut(),
545 Self::Pass(node) => node.range_mut(),
546 Self::Break(node) => node.range_mut(),
547 Self::Continue(node) => node.range_mut(),
548 }
549 }
550}
551
552pub type Expr = crate::generic::Expr<SourceRange>;
553
554pub type ExprBoolOp = crate::generic::ExprBoolOp<SourceRange>;
555
556impl Located for ExprBoolOp {
557 fn range(&self) -> SourceRange {
558 self.range
559 }
560}
561
562impl LocatedMut for ExprBoolOp {
563 fn range_mut(&mut self) -> &mut SourceRange {
564 &mut self.range
565 }
566}
567
568pub type ExprNamedExpr = crate::generic::ExprNamedExpr<SourceRange>;
569
570impl Located for ExprNamedExpr {
571 fn range(&self) -> SourceRange {
572 self.range
573 }
574}
575
576impl LocatedMut for ExprNamedExpr {
577 fn range_mut(&mut self) -> &mut SourceRange {
578 &mut self.range
579 }
580}
581
582pub type ExprBinOp = crate::generic::ExprBinOp<SourceRange>;
583
584impl Located for ExprBinOp {
585 fn range(&self) -> SourceRange {
586 self.range
587 }
588}
589
590impl LocatedMut for ExprBinOp {
591 fn range_mut(&mut self) -> &mut SourceRange {
592 &mut self.range
593 }
594}
595
596pub type ExprUnaryOp = crate::generic::ExprUnaryOp<SourceRange>;
597
598impl Located for ExprUnaryOp {
599 fn range(&self) -> SourceRange {
600 self.range
601 }
602}
603
604impl LocatedMut for ExprUnaryOp {
605 fn range_mut(&mut self) -> &mut SourceRange {
606 &mut self.range
607 }
608}
609
610pub type ExprLambda = crate::generic::ExprLambda<SourceRange>;
611
612impl Located for ExprLambda {
613 fn range(&self) -> SourceRange {
614 self.range
615 }
616}
617
618impl LocatedMut for ExprLambda {
619 fn range_mut(&mut self) -> &mut SourceRange {
620 &mut self.range
621 }
622}
623
624pub type ExprIfExp = crate::generic::ExprIfExp<SourceRange>;
625
626impl Located for ExprIfExp {
627 fn range(&self) -> SourceRange {
628 self.range
629 }
630}
631
632impl LocatedMut for ExprIfExp {
633 fn range_mut(&mut self) -> &mut SourceRange {
634 &mut self.range
635 }
636}
637
638pub type ExprDict = crate::generic::ExprDict<SourceRange>;
639
640impl Located for ExprDict {
641 fn range(&self) -> SourceRange {
642 self.range
643 }
644}
645
646impl LocatedMut for ExprDict {
647 fn range_mut(&mut self) -> &mut SourceRange {
648 &mut self.range
649 }
650}
651
652pub type ExprSet = crate::generic::ExprSet<SourceRange>;
653
654impl Located for ExprSet {
655 fn range(&self) -> SourceRange {
656 self.range
657 }
658}
659
660impl LocatedMut for ExprSet {
661 fn range_mut(&mut self) -> &mut SourceRange {
662 &mut self.range
663 }
664}
665
666pub type ExprListComp = crate::generic::ExprListComp<SourceRange>;
667
668impl Located for ExprListComp {
669 fn range(&self) -> SourceRange {
670 self.range
671 }
672}
673
674impl LocatedMut for ExprListComp {
675 fn range_mut(&mut self) -> &mut SourceRange {
676 &mut self.range
677 }
678}
679
680pub type ExprSetComp = crate::generic::ExprSetComp<SourceRange>;
681
682impl Located for ExprSetComp {
683 fn range(&self) -> SourceRange {
684 self.range
685 }
686}
687
688impl LocatedMut for ExprSetComp {
689 fn range_mut(&mut self) -> &mut SourceRange {
690 &mut self.range
691 }
692}
693
694pub type ExprDictComp = crate::generic::ExprDictComp<SourceRange>;
695
696impl Located for ExprDictComp {
697 fn range(&self) -> SourceRange {
698 self.range
699 }
700}
701
702impl LocatedMut for ExprDictComp {
703 fn range_mut(&mut self) -> &mut SourceRange {
704 &mut self.range
705 }
706}
707
708pub type ExprGeneratorExp = crate::generic::ExprGeneratorExp<SourceRange>;
709
710impl Located for ExprGeneratorExp {
711 fn range(&self) -> SourceRange {
712 self.range
713 }
714}
715
716impl LocatedMut for ExprGeneratorExp {
717 fn range_mut(&mut self) -> &mut SourceRange {
718 &mut self.range
719 }
720}
721
722pub type ExprAwait = crate::generic::ExprAwait<SourceRange>;
723
724impl Located for ExprAwait {
725 fn range(&self) -> SourceRange {
726 self.range
727 }
728}
729
730impl LocatedMut for ExprAwait {
731 fn range_mut(&mut self) -> &mut SourceRange {
732 &mut self.range
733 }
734}
735
736pub type ExprYield = crate::generic::ExprYield<SourceRange>;
737
738impl Located for ExprYield {
739 fn range(&self) -> SourceRange {
740 self.range
741 }
742}
743
744impl LocatedMut for ExprYield {
745 fn range_mut(&mut self) -> &mut SourceRange {
746 &mut self.range
747 }
748}
749
750pub type ExprYieldFrom = crate::generic::ExprYieldFrom<SourceRange>;
751
752impl Located for ExprYieldFrom {
753 fn range(&self) -> SourceRange {
754 self.range
755 }
756}
757
758impl LocatedMut for ExprYieldFrom {
759 fn range_mut(&mut self) -> &mut SourceRange {
760 &mut self.range
761 }
762}
763
764pub type ExprCompare = crate::generic::ExprCompare<SourceRange>;
765
766impl Located for ExprCompare {
767 fn range(&self) -> SourceRange {
768 self.range
769 }
770}
771
772impl LocatedMut for ExprCompare {
773 fn range_mut(&mut self) -> &mut SourceRange {
774 &mut self.range
775 }
776}
777
778pub type ExprCall = crate::generic::ExprCall<SourceRange>;
779
780impl Located for ExprCall {
781 fn range(&self) -> SourceRange {
782 self.range
783 }
784}
785
786impl LocatedMut for ExprCall {
787 fn range_mut(&mut self) -> &mut SourceRange {
788 &mut self.range
789 }
790}
791
792pub type ExprFormattedValue = crate::generic::ExprFormattedValue<SourceRange>;
793
794impl Located for ExprFormattedValue {
795 fn range(&self) -> SourceRange {
796 self.range
797 }
798}
799
800impl LocatedMut for ExprFormattedValue {
801 fn range_mut(&mut self) -> &mut SourceRange {
802 &mut self.range
803 }
804}
805
806pub type ExprJoinedStr = crate::generic::ExprJoinedStr<SourceRange>;
807
808impl Located for ExprJoinedStr {
809 fn range(&self) -> SourceRange {
810 self.range
811 }
812}
813
814impl LocatedMut for ExprJoinedStr {
815 fn range_mut(&mut self) -> &mut SourceRange {
816 &mut self.range
817 }
818}
819
820pub type ExprConstant = crate::generic::ExprConstant<SourceRange>;
821
822impl Located for ExprConstant {
823 fn range(&self) -> SourceRange {
824 self.range
825 }
826}
827
828impl LocatedMut for ExprConstant {
829 fn range_mut(&mut self) -> &mut SourceRange {
830 &mut self.range
831 }
832}
833
834pub type ExprAttribute = crate::generic::ExprAttribute<SourceRange>;
835
836impl Located for ExprAttribute {
837 fn range(&self) -> SourceRange {
838 self.range
839 }
840}
841
842impl LocatedMut for ExprAttribute {
843 fn range_mut(&mut self) -> &mut SourceRange {
844 &mut self.range
845 }
846}
847
848pub type ExprSubscript = crate::generic::ExprSubscript<SourceRange>;
849
850impl Located for ExprSubscript {
851 fn range(&self) -> SourceRange {
852 self.range
853 }
854}
855
856impl LocatedMut for ExprSubscript {
857 fn range_mut(&mut self) -> &mut SourceRange {
858 &mut self.range
859 }
860}
861
862pub type ExprStarred = crate::generic::ExprStarred<SourceRange>;
863
864impl Located for ExprStarred {
865 fn range(&self) -> SourceRange {
866 self.range
867 }
868}
869
870impl LocatedMut for ExprStarred {
871 fn range_mut(&mut self) -> &mut SourceRange {
872 &mut self.range
873 }
874}
875
876pub type ExprName = crate::generic::ExprName<SourceRange>;
877
878impl Located for ExprName {
879 fn range(&self) -> SourceRange {
880 self.range
881 }
882}
883
884impl LocatedMut for ExprName {
885 fn range_mut(&mut self) -> &mut SourceRange {
886 &mut self.range
887 }
888}
889
890pub type ExprList = crate::generic::ExprList<SourceRange>;
891
892impl Located for ExprList {
893 fn range(&self) -> SourceRange {
894 self.range
895 }
896}
897
898impl LocatedMut for ExprList {
899 fn range_mut(&mut self) -> &mut SourceRange {
900 &mut self.range
901 }
902}
903
904pub type ExprTuple = crate::generic::ExprTuple<SourceRange>;
905
906impl Located for ExprTuple {
907 fn range(&self) -> SourceRange {
908 self.range
909 }
910}
911
912impl LocatedMut for ExprTuple {
913 fn range_mut(&mut self) -> &mut SourceRange {
914 &mut self.range
915 }
916}
917
918pub type ExprSlice = crate::generic::ExprSlice<SourceRange>;
919
920impl Located for ExprSlice {
921 fn range(&self) -> SourceRange {
922 self.range
923 }
924}
925
926impl LocatedMut for ExprSlice {
927 fn range_mut(&mut self) -> &mut SourceRange {
928 &mut self.range
929 }
930}
931
932impl Located for Expr {
933 fn range(&self) -> SourceRange {
934 match self {
935 Self::BoolOp(node) => node.range(),
936 Self::NamedExpr(node) => node.range(),
937 Self::BinOp(node) => node.range(),
938 Self::UnaryOp(node) => node.range(),
939 Self::Lambda(node) => node.range(),
940 Self::IfExp(node) => node.range(),
941 Self::Dict(node) => node.range(),
942 Self::Set(node) => node.range(),
943 Self::ListComp(node) => node.range(),
944 Self::SetComp(node) => node.range(),
945 Self::DictComp(node) => node.range(),
946 Self::GeneratorExp(node) => node.range(),
947 Self::Await(node) => node.range(),
948 Self::Yield(node) => node.range(),
949 Self::YieldFrom(node) => node.range(),
950 Self::Compare(node) => node.range(),
951 Self::Call(node) => node.range(),
952 Self::FormattedValue(node) => node.range(),
953 Self::JoinedStr(node) => node.range(),
954 Self::Constant(node) => node.range(),
955 Self::Attribute(node) => node.range(),
956 Self::Subscript(node) => node.range(),
957 Self::Starred(node) => node.range(),
958 Self::Name(node) => node.range(),
959 Self::List(node) => node.range(),
960 Self::Tuple(node) => node.range(),
961 Self::Slice(node) => node.range(),
962 }
963 }
964}
965
966impl LocatedMut for Expr {
967 fn range_mut(&mut self) -> &mut SourceRange {
968 match self {
969 Self::BoolOp(node) => node.range_mut(),
970 Self::NamedExpr(node) => node.range_mut(),
971 Self::BinOp(node) => node.range_mut(),
972 Self::UnaryOp(node) => node.range_mut(),
973 Self::Lambda(node) => node.range_mut(),
974 Self::IfExp(node) => node.range_mut(),
975 Self::Dict(node) => node.range_mut(),
976 Self::Set(node) => node.range_mut(),
977 Self::ListComp(node) => node.range_mut(),
978 Self::SetComp(node) => node.range_mut(),
979 Self::DictComp(node) => node.range_mut(),
980 Self::GeneratorExp(node) => node.range_mut(),
981 Self::Await(node) => node.range_mut(),
982 Self::Yield(node) => node.range_mut(),
983 Self::YieldFrom(node) => node.range_mut(),
984 Self::Compare(node) => node.range_mut(),
985 Self::Call(node) => node.range_mut(),
986 Self::FormattedValue(node) => node.range_mut(),
987 Self::JoinedStr(node) => node.range_mut(),
988 Self::Constant(node) => node.range_mut(),
989 Self::Attribute(node) => node.range_mut(),
990 Self::Subscript(node) => node.range_mut(),
991 Self::Starred(node) => node.range_mut(),
992 Self::Name(node) => node.range_mut(),
993 Self::List(node) => node.range_mut(),
994 Self::Tuple(node) => node.range_mut(),
995 Self::Slice(node) => node.range_mut(),
996 }
997 }
998}
999
1000pub type ExprContext = crate::generic::ExprContext;
1001
1002pub type ExprContextLoad = crate::generic::ExprContextLoad;
1003
1004pub type ExprContextStore = crate::generic::ExprContextStore;
1005
1006pub type ExprContextDel = crate::generic::ExprContextDel;
1007
1008pub type BoolOp = crate::generic::BoolOp;
1009
1010pub type BoolOpAnd = crate::generic::BoolOpAnd;
1011
1012pub type BoolOpOr = crate::generic::BoolOpOr;
1013
1014pub type Operator = crate::generic::Operator;
1015
1016pub type OperatorAdd = crate::generic::OperatorAdd;
1017
1018pub type OperatorSub = crate::generic::OperatorSub;
1019
1020pub type OperatorMult = crate::generic::OperatorMult;
1021
1022pub type OperatorMatMult = crate::generic::OperatorMatMult;
1023
1024pub type OperatorDiv = crate::generic::OperatorDiv;
1025
1026pub type OperatorMod = crate::generic::OperatorMod;
1027
1028pub type OperatorPow = crate::generic::OperatorPow;
1029
1030pub type OperatorLShift = crate::generic::OperatorLShift;
1031
1032pub type OperatorRShift = crate::generic::OperatorRShift;
1033
1034pub type OperatorBitOr = crate::generic::OperatorBitOr;
1035
1036pub type OperatorBitXor = crate::generic::OperatorBitXor;
1037
1038pub type OperatorBitAnd = crate::generic::OperatorBitAnd;
1039
1040pub type OperatorFloorDiv = crate::generic::OperatorFloorDiv;
1041
1042pub type UnaryOp = crate::generic::UnaryOp;
1043
1044pub type UnaryOpInvert = crate::generic::UnaryOpInvert;
1045
1046pub type UnaryOpNot = crate::generic::UnaryOpNot;
1047
1048pub type UnaryOpUAdd = crate::generic::UnaryOpUAdd;
1049
1050pub type UnaryOpUSub = crate::generic::UnaryOpUSub;
1051
1052pub type CmpOp = crate::generic::CmpOp;
1053
1054pub type CmpOpEq = crate::generic::CmpOpEq;
1055
1056pub type CmpOpNotEq = crate::generic::CmpOpNotEq;
1057
1058pub type CmpOpLt = crate::generic::CmpOpLt;
1059
1060pub type CmpOpLtE = crate::generic::CmpOpLtE;
1061
1062pub type CmpOpGt = crate::generic::CmpOpGt;
1063
1064pub type CmpOpGtE = crate::generic::CmpOpGtE;
1065
1066pub type CmpOpIs = crate::generic::CmpOpIs;
1067
1068pub type CmpOpIsNot = crate::generic::CmpOpIsNot;
1069
1070pub type CmpOpIn = crate::generic::CmpOpIn;
1071
1072pub type CmpOpNotIn = crate::generic::CmpOpNotIn;
1073
1074pub type Comprehension = crate::generic::Comprehension<SourceRange>;
1075
1076#[cfg(feature = "all-nodes-with-ranges")]
1077impl Located for Comprehension {
1078 fn range(&self) -> SourceRange {
1079 self.range
1080 }
1081}
1082#[cfg(feature = "all-nodes-with-ranges")]
1083impl LocatedMut for Comprehension {
1084 fn range_mut(&mut self) -> &mut SourceRange {
1085 &mut self.range
1086 }
1087}
1088
1089pub type ExceptHandler = crate::generic::ExceptHandler<SourceRange>;
1090
1091pub type ExceptHandlerExceptHandler = crate::generic::ExceptHandlerExceptHandler<SourceRange>;
1092
1093impl Located for ExceptHandlerExceptHandler {
1094 fn range(&self) -> SourceRange {
1095 self.range
1096 }
1097}
1098
1099impl LocatedMut for ExceptHandlerExceptHandler {
1100 fn range_mut(&mut self) -> &mut SourceRange {
1101 &mut self.range
1102 }
1103}
1104
1105impl Located for ExceptHandler {
1106 fn range(&self) -> SourceRange {
1107 match self {
1108 Self::ExceptHandler(node) => node.range(),
1109 }
1110 }
1111}
1112
1113impl LocatedMut for ExceptHandler {
1114 fn range_mut(&mut self) -> &mut SourceRange {
1115 match self {
1116 Self::ExceptHandler(node) => node.range_mut(),
1117 }
1118 }
1119}
1120
1121pub type PythonArguments = crate::generic::PythonArguments<SourceRange>;
1122
1123#[cfg(feature = "all-nodes-with-ranges")]
1124impl Located for PythonArguments {
1125 fn range(&self) -> SourceRange {
1126 self.range
1127 }
1128}
1129#[cfg(feature = "all-nodes-with-ranges")]
1130impl LocatedMut for PythonArguments {
1131 fn range_mut(&mut self) -> &mut SourceRange {
1132 &mut self.range
1133 }
1134}
1135
1136pub type Arg = crate::generic::Arg<SourceRange>;
1137
1138impl Located for Arg {
1139 fn range(&self) -> SourceRange {
1140 self.range
1141 }
1142}
1143
1144impl LocatedMut for Arg {
1145 fn range_mut(&mut self) -> &mut SourceRange {
1146 &mut self.range
1147 }
1148}
1149
1150pub type Keyword = crate::generic::Keyword<SourceRange>;
1151
1152impl Located for Keyword {
1153 fn range(&self) -> SourceRange {
1154 self.range
1155 }
1156}
1157
1158impl LocatedMut for Keyword {
1159 fn range_mut(&mut self) -> &mut SourceRange {
1160 &mut self.range
1161 }
1162}
1163
1164pub type Alias = crate::generic::Alias<SourceRange>;
1165
1166impl Located for Alias {
1167 fn range(&self) -> SourceRange {
1168 self.range
1169 }
1170}
1171
1172impl LocatedMut for Alias {
1173 fn range_mut(&mut self) -> &mut SourceRange {
1174 &mut self.range
1175 }
1176}
1177
1178pub type WithItem = crate::generic::WithItem<SourceRange>;
1179
1180#[cfg(feature = "all-nodes-with-ranges")]
1181impl Located for WithItem {
1182 fn range(&self) -> SourceRange {
1183 self.range
1184 }
1185}
1186#[cfg(feature = "all-nodes-with-ranges")]
1187impl LocatedMut for WithItem {
1188 fn range_mut(&mut self) -> &mut SourceRange {
1189 &mut self.range
1190 }
1191}
1192
1193pub type MatchCase = crate::generic::MatchCase<SourceRange>;
1194
1195#[cfg(feature = "all-nodes-with-ranges")]
1196impl Located for MatchCase {
1197 fn range(&self) -> SourceRange {
1198 self.range
1199 }
1200}
1201#[cfg(feature = "all-nodes-with-ranges")]
1202impl LocatedMut for MatchCase {
1203 fn range_mut(&mut self) -> &mut SourceRange {
1204 &mut self.range
1205 }
1206}
1207
1208pub type Pattern = crate::generic::Pattern<SourceRange>;
1209
1210pub type PatternMatchValue = crate::generic::PatternMatchValue<SourceRange>;
1211
1212impl Located for PatternMatchValue {
1213 fn range(&self) -> SourceRange {
1214 self.range
1215 }
1216}
1217
1218impl LocatedMut for PatternMatchValue {
1219 fn range_mut(&mut self) -> &mut SourceRange {
1220 &mut self.range
1221 }
1222}
1223
1224pub type PatternMatchSingleton = crate::generic::PatternMatchSingleton<SourceRange>;
1225
1226impl Located for PatternMatchSingleton {
1227 fn range(&self) -> SourceRange {
1228 self.range
1229 }
1230}
1231
1232impl LocatedMut for PatternMatchSingleton {
1233 fn range_mut(&mut self) -> &mut SourceRange {
1234 &mut self.range
1235 }
1236}
1237
1238pub type PatternMatchSequence = crate::generic::PatternMatchSequence<SourceRange>;
1239
1240impl Located for PatternMatchSequence {
1241 fn range(&self) -> SourceRange {
1242 self.range
1243 }
1244}
1245
1246impl LocatedMut for PatternMatchSequence {
1247 fn range_mut(&mut self) -> &mut SourceRange {
1248 &mut self.range
1249 }
1250}
1251
1252pub type PatternMatchMapping = crate::generic::PatternMatchMapping<SourceRange>;
1253
1254impl Located for PatternMatchMapping {
1255 fn range(&self) -> SourceRange {
1256 self.range
1257 }
1258}
1259
1260impl LocatedMut for PatternMatchMapping {
1261 fn range_mut(&mut self) -> &mut SourceRange {
1262 &mut self.range
1263 }
1264}
1265
1266pub type PatternMatchClass = crate::generic::PatternMatchClass<SourceRange>;
1267
1268impl Located for PatternMatchClass {
1269 fn range(&self) -> SourceRange {
1270 self.range
1271 }
1272}
1273
1274impl LocatedMut for PatternMatchClass {
1275 fn range_mut(&mut self) -> &mut SourceRange {
1276 &mut self.range
1277 }
1278}
1279
1280pub type PatternMatchStar = crate::generic::PatternMatchStar<SourceRange>;
1281
1282impl Located for PatternMatchStar {
1283 fn range(&self) -> SourceRange {
1284 self.range
1285 }
1286}
1287
1288impl LocatedMut for PatternMatchStar {
1289 fn range_mut(&mut self) -> &mut SourceRange {
1290 &mut self.range
1291 }
1292}
1293
1294pub type PatternMatchAs = crate::generic::PatternMatchAs<SourceRange>;
1295
1296impl Located for PatternMatchAs {
1297 fn range(&self) -> SourceRange {
1298 self.range
1299 }
1300}
1301
1302impl LocatedMut for PatternMatchAs {
1303 fn range_mut(&mut self) -> &mut SourceRange {
1304 &mut self.range
1305 }
1306}
1307
1308pub type PatternMatchOr = crate::generic::PatternMatchOr<SourceRange>;
1309
1310impl Located for PatternMatchOr {
1311 fn range(&self) -> SourceRange {
1312 self.range
1313 }
1314}
1315
1316impl LocatedMut for PatternMatchOr {
1317 fn range_mut(&mut self) -> &mut SourceRange {
1318 &mut self.range
1319 }
1320}
1321
1322impl Located for Pattern {
1323 fn range(&self) -> SourceRange {
1324 match self {
1325 Self::MatchValue(node) => node.range(),
1326 Self::MatchSingleton(node) => node.range(),
1327 Self::MatchSequence(node) => node.range(),
1328 Self::MatchMapping(node) => node.range(),
1329 Self::MatchClass(node) => node.range(),
1330 Self::MatchStar(node) => node.range(),
1331 Self::MatchAs(node) => node.range(),
1332 Self::MatchOr(node) => node.range(),
1333 }
1334 }
1335}
1336
1337impl LocatedMut for Pattern {
1338 fn range_mut(&mut self) -> &mut SourceRange {
1339 match self {
1340 Self::MatchValue(node) => node.range_mut(),
1341 Self::MatchSingleton(node) => node.range_mut(),
1342 Self::MatchSequence(node) => node.range_mut(),
1343 Self::MatchMapping(node) => node.range_mut(),
1344 Self::MatchClass(node) => node.range_mut(),
1345 Self::MatchStar(node) => node.range_mut(),
1346 Self::MatchAs(node) => node.range_mut(),
1347 Self::MatchOr(node) => node.range_mut(),
1348 }
1349 }
1350}
1351
1352pub type TypeIgnore = crate::generic::TypeIgnore<SourceRange>;
1353
1354pub type TypeIgnoreTypeIgnore = crate::generic::TypeIgnoreTypeIgnore<SourceRange>;
1355
1356#[cfg(feature = "all-nodes-with-ranges")]
1357impl Located for TypeIgnoreTypeIgnore {
1358 fn range(&self) -> SourceRange {
1359 self.range
1360 }
1361}
1362#[cfg(feature = "all-nodes-with-ranges")]
1363impl LocatedMut for TypeIgnoreTypeIgnore {
1364 fn range_mut(&mut self) -> &mut SourceRange {
1365 &mut self.range
1366 }
1367}
1368
1369#[cfg(feature = "all-nodes-with-ranges")]
1370impl Located for TypeIgnore {
1371 fn range(&self) -> SourceRange {
1372 match self {
1373 Self::TypeIgnore(node) => node.range(),
1374 }
1375 }
1376}
1377#[cfg(feature = "all-nodes-with-ranges")]
1378impl LocatedMut for TypeIgnore {
1379 fn range_mut(&mut self) -> &mut SourceRange {
1380 match self {
1381 Self::TypeIgnore(node) => node.range_mut(),
1382 }
1383 }
1384}
1385
1386pub type TypeParam = crate::generic::TypeParam<SourceRange>;
1387
1388pub type TypeParamTypeVar = crate::generic::TypeParamTypeVar<SourceRange>;
1389
1390impl Located for TypeParamTypeVar {
1391 fn range(&self) -> SourceRange {
1392 self.range
1393 }
1394}
1395
1396impl LocatedMut for TypeParamTypeVar {
1397 fn range_mut(&mut self) -> &mut SourceRange {
1398 &mut self.range
1399 }
1400}
1401
1402pub type TypeParamParamSpec = crate::generic::TypeParamParamSpec<SourceRange>;
1403
1404impl Located for TypeParamParamSpec {
1405 fn range(&self) -> SourceRange {
1406 self.range
1407 }
1408}
1409
1410impl LocatedMut for TypeParamParamSpec {
1411 fn range_mut(&mut self) -> &mut SourceRange {
1412 &mut self.range
1413 }
1414}
1415
1416pub type TypeParamTypeVarTuple = crate::generic::TypeParamTypeVarTuple<SourceRange>;
1417
1418impl Located for TypeParamTypeVarTuple {
1419 fn range(&self) -> SourceRange {
1420 self.range
1421 }
1422}
1423
1424impl LocatedMut for TypeParamTypeVarTuple {
1425 fn range_mut(&mut self) -> &mut SourceRange {
1426 &mut self.range
1427 }
1428}
1429
1430impl Located for TypeParam {
1431 fn range(&self) -> SourceRange {
1432 match self {
1433 Self::TypeVar(node) => node.range(),
1434 Self::ParamSpec(node) => node.range(),
1435 Self::TypeVarTuple(node) => node.range(),
1436 }
1437 }
1438}
1439
1440impl LocatedMut for TypeParam {
1441 fn range_mut(&mut self) -> &mut SourceRange {
1442 match self {
1443 Self::TypeVar(node) => node.range_mut(),
1444 Self::ParamSpec(node) => node.range_mut(),
1445 Self::TypeVarTuple(node) => node.range_mut(),
1446 }
1447 }
1448}
1449
1450pub type Arguments = crate::generic::Arguments<SourceRange>;
1451
1452#[cfg(feature = "all-nodes-with-ranges")]
1453impl Located for Arguments {
1454 fn range(&self) -> SourceRange {
1455 self.range
1456 }
1457}
1458#[cfg(feature = "all-nodes-with-ranges")]
1459impl LocatedMut for Arguments {
1460 fn range_mut(&mut self) -> &mut SourceRange {
1461 &mut self.range
1462 }
1463}
1464
1465pub type ArgWithDefault = crate::generic::ArgWithDefault<SourceRange>;
1466
1467#[cfg(feature = "all-nodes-with-ranges")]
1468impl Located for ArgWithDefault {
1469 fn range(&self) -> SourceRange {
1470 self.range
1471 }
1472}
1473#[cfg(feature = "all-nodes-with-ranges")]
1474impl LocatedMut for ArgWithDefault {
1475 fn range_mut(&mut self) -> &mut SourceRange {
1476 &mut self.range
1477 }
1478}