language-servers/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-07-24 13:34:40 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
ruff/crates/ruff_python_parser/tests/snapshots/valid_syntax@statement__match.py.snap
Micha Reiser 5109b50bb3
Use CompactString for Identifier (#12101)
2024-07-01 10:06:02 +02:00

7716 lines
391 KiB
Text
Raw Blame History

---
source: crates/ruff_python_parser/tests/fixtures.rs
input_file: crates/ruff_python_parser/resources/valid/statement/match.py
---
## AST
```
Module(
ModModule {
range: 0..5743,
body: [
Match(
StmtMatch {
range: 67..103,
subject: Name(
ExprName {
range: 73..74,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 80..103,
pattern: MatchValue(
PatternMatchValue {
range: 85..88,
value: UnaryOp(
ExprUnaryOp {
range: 85..88,
op: USub,
operand: NumberLiteral(
ExprNumberLiteral {
range: 86..88,
value: Complex {
real: 0.0,
imag: 0.0,
},
},
),
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 98..103,
targets: [
Name(
ExprName {
range: 98..99,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 102..103,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 126..167,
subject: Name(
ExprName {
range: 132..133,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 139..167,
pattern: MatchClass(
PatternMatchClass {
range: 144..152,
cls: Name(
ExprName {
range: 144..149,
id: Name("bytes"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 149..152,
patterns: [
MatchAs(
PatternMatchAs {
range: 150..151,
pattern: None,
name: Some(
Identifier {
id: Name("z"),
range: 150..151,
},
),
},
),
],
keywords: [],
},
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 162..167,
targets: [
Name(
ExprName {
range: 162..163,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 166..167,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 190..260,
subject: Name(
ExprName {
range: 196..197,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 203..229,
pattern: MatchValue(
PatternMatchValue {
range: 208..209,
value: NumberLiteral(
ExprNumberLiteral {
range: 208..209,
value: Int(
0,
),
},
),
},
),
guard: Some(
NumberLiteral(
ExprNumberLiteral {
range: 213..214,
value: Int(
0,
),
},
),
),
body: [
Assign(
StmtAssign {
range: 224..229,
targets: [
Name(
ExprName {
range: 224..225,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 228..229,
value: Int(
0,
),
},
),
},
),
],
},
MatchCase {
range: 234..260,
pattern: MatchValue(
PatternMatchValue {
range: 239..240,
value: NumberLiteral(
ExprNumberLiteral {
range: 239..240,
value: Int(
0,
),
},
),
},
),
guard: Some(
NumberLiteral(
ExprNumberLiteral {
range: 244..245,
value: Int(
1,
),
},
),
),
body: [
Assign(
StmtAssign {
range: 255..260,
targets: [
Name(
ExprName {
range: 255..256,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 259..260,
value: Int(
1,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 283..332,
subject: NumberLiteral(
ExprNumberLiteral {
range: 289..290,
value: Int(
3,
),
},
),
cases: [
MatchCase {
range: 296..332,
pattern: MatchOr(
PatternMatchOr {
range: 301..314,
patterns: [
MatchValue(
PatternMatchValue {
range: 301..302,
value: NumberLiteral(
ExprNumberLiteral {
range: 301..302,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 305..306,
value: NumberLiteral(
ExprNumberLiteral {
range: 305..306,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 309..310,
value: NumberLiteral(
ExprNumberLiteral {
range: 309..310,
value: Int(
2,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 313..314,
value: NumberLiteral(
ExprNumberLiteral {
range: 313..314,
value: Int(
3,
),
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 324..332,
targets: [
Name(
ExprName {
range: 324..325,
id: Name("x"),
ctx: Store,
},
),
],
value: BooleanLiteral(
ExprBooleanLiteral {
range: 328..332,
value: true,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 355..403,
subject: Name(
ExprName {
range: 361..362,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 368..403,
pattern: MatchOr(
PatternMatchOr {
range: 373..388,
patterns: [
MatchSequence(
PatternMatchSequence {
range: 373..379,
patterns: [
MatchValue(
PatternMatchValue {
range: 374..375,
value: NumberLiteral(
ExprNumberLiteral {
range: 374..375,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 377..378,
value: NumberLiteral(
ExprNumberLiteral {
range: 377..378,
value: Int(
1,
),
},
),
},
),
],
},
),
MatchSequence(
PatternMatchSequence {
range: 382..388,
patterns: [
MatchValue(
PatternMatchValue {
range: 383..384,
value: NumberLiteral(
ExprNumberLiteral {
range: 383..384,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 386..387,
value: NumberLiteral(
ExprNumberLiteral {
range: 386..387,
value: Int(
0,
),
},
),
},
),
],
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 398..403,
targets: [
Name(
ExprName {
range: 398..399,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 402..403,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 445..523,
subject: Name(
ExprName {
range: 451..452,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 458..489,
pattern: MatchSequence(
PatternMatchSequence {
range: 463..467,
patterns: [
MatchStar(
PatternMatchStar {
range: 464..466,
name: None,
},
),
],
},
),
guard: None,
body: [
Return(
StmtReturn {
range: 477..489,
value: Some(
StringLiteral(
ExprStringLiteral {
range: 484..489,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 484..489,
value: "seq",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
),
},
),
],
},
MatchCase {
range: 494..523,
pattern: MatchMapping(
PatternMatchMapping {
range: 499..501,
keys: [],
patterns: [],
rest: None,
},
),
guard: None,
body: [
Return(
StmtReturn {
range: 511..523,
value: Some(
StringLiteral(
ExprStringLiteral {
range: 518..523,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 518..523,
value: "map",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 546..714,
subject: Name(
ExprName {
range: 552..553,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 559..594,
pattern: MatchMapping(
PatternMatchMapping {
range: 564..579,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 565..566,
value: Int(
0,
),
},
),
],
patterns: [
MatchSequence(
PatternMatchSequence {
range: 568..578,
patterns: [
MatchValue(
PatternMatchValue {
range: 569..570,
value: NumberLiteral(
ExprNumberLiteral {
range: 569..570,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 572..573,
value: NumberLiteral(
ExprNumberLiteral {
range: 572..573,
value: Int(
2,
),
},
),
},
),
MatchMapping(
PatternMatchMapping {
range: 575..577,
keys: [],
patterns: [],
rest: None,
},
),
],
},
),
],
rest: None,
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 589..594,
targets: [
Name(
ExprName {
range: 589..590,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 593..594,
value: Int(
0,
),
},
),
},
),
],
},
MatchCase {
range: 599..687,
pattern: MatchOr(
PatternMatchOr {
range: 604..672,
patterns: [
MatchMapping(
PatternMatchMapping {
range: 604..626,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 605..606,
value: Int(
0,
),
},
),
],
patterns: [
MatchOr(
PatternMatchOr {
range: 608..625,
patterns: [
MatchSequence(
PatternMatchSequence {
range: 608..618,
patterns: [
MatchValue(
PatternMatchValue {
range: 609..610,
value: NumberLiteral(
ExprNumberLiteral {
range: 609..610,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 612..613,
value: NumberLiteral(
ExprNumberLiteral {
range: 612..613,
value: Int(
2,
),
},
),
},
),
MatchMapping(
PatternMatchMapping {
range: 615..617,
keys: [],
patterns: [],
rest: None,
},
),
],
},
),
MatchSingleton(
PatternMatchSingleton {
range: 621..625,
value: True,
},
),
],
},
),
],
rest: None,
},
),
MatchMapping(
PatternMatchMapping {
range: 629..638,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 630..631,
value: Int(
1,
),
},
),
],
patterns: [
MatchSequence(
PatternMatchSequence {
range: 633..637,
patterns: [
MatchSequence(
PatternMatchSequence {
range: 634..636,
patterns: [],
},
),
],
},
),
],
rest: None,
},
),
MatchMapping(
PatternMatchMapping {
range: 641..656,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 642..643,
value: Int(
0,
),
},
),
],
patterns: [
MatchSequence(
PatternMatchSequence {
range: 645..655,
patterns: [
MatchValue(
PatternMatchValue {
range: 646..647,
value: NumberLiteral(
ExprNumberLiteral {
range: 646..647,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 649..650,
value: NumberLiteral(
ExprNumberLiteral {
range: 649..650,
value: Int(
2,
),
},
),
},
),
MatchMapping(
PatternMatchMapping {
range: 652..654,
keys: [],
patterns: [],
rest: None,
},
),
],
},
),
],
rest: None,
},
),
MatchSequence(
PatternMatchSequence {
range: 659..661,
patterns: [],
},
),
MatchValue(
PatternMatchValue {
range: 664..667,
value: StringLiteral(
ExprStringLiteral {
range: 664..667,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 664..667,
value: "X",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
},
),
MatchMapping(
PatternMatchMapping {
range: 670..672,
keys: [],
patterns: [],
rest: None,
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 682..687,
targets: [
Name(
ExprName {
range: 682..683,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 686..687,
value: Int(
1,
),
},
),
},
),
],
},
MatchCase {
range: 692..714,
pattern: MatchSequence(
PatternMatchSequence {
range: 697..699,
patterns: [],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 709..714,
targets: [
Name(
ExprName {
range: 709..710,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 713..714,
value: Int(
2,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 737..782,
subject: Name(
ExprName {
range: 743..744,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 750..782,
pattern: MatchValue(
PatternMatchValue {
range: 755..767,
value: BinOp(
ExprBinOp {
range: 755..767,
left: NumberLiteral(
ExprNumberLiteral {
range: 755..759,
value: Float(
0.25,
),
},
),
op: Add,
right: NumberLiteral(
ExprNumberLiteral {
range: 762..767,
value: Complex {
real: 0.0,
imag: 1.75,
},
},
),
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 777..782,
targets: [
Name(
ExprName {
range: 777..778,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 781..782,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 805..841,
subject: Name(
ExprName {
range: 811..812,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 818..841,
pattern: MatchValue(
PatternMatchValue {
range: 823..826,
value: UnaryOp(
ExprUnaryOp {
range: 823..826,
op: USub,
operand: NumberLiteral(
ExprNumberLiteral {
range: 824..826,
value: Complex {
real: 0.0,
imag: 0.0,
},
},
),
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 836..841,
targets: [
Name(
ExprName {
range: 836..837,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 840..841,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 864..913,
subject: NumberLiteral(
ExprNumberLiteral {
range: 870..871,
value: Int(
4,
),
},
),
cases: [
MatchCase {
range: 877..913,
pattern: MatchOr(
PatternMatchOr {
range: 882..895,
patterns: [
MatchValue(
PatternMatchValue {
range: 882..883,
value: NumberLiteral(
ExprNumberLiteral {
range: 882..883,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 886..887,
value: NumberLiteral(
ExprNumberLiteral {
range: 886..887,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 890..891,
value: NumberLiteral(
ExprNumberLiteral {
range: 890..891,
value: Int(
2,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 894..895,
value: NumberLiteral(
ExprNumberLiteral {
range: 894..895,
value: Int(
3,
),
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 905..913,
targets: [
Name(
ExprName {
range: 905..906,
id: Name("x"),
ctx: Store,
},
),
],
value: BooleanLiteral(
ExprBooleanLiteral {
range: 909..913,
value: true,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 936..975,
subject: Name(
ExprName {
range: 942..943,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 949..975,
pattern: MatchValue(
PatternMatchValue {
range: 954..955,
value: NumberLiteral(
ExprNumberLiteral {
range: 954..955,
value: Int(
0,
),
},
),
},
),
guard: Some(
Name(
ExprName {
range: 959..960,
id: Name("x"),
ctx: Load,
},
),
),
body: [
Assign(
StmtAssign {
range: 970..975,
targets: [
Name(
ExprName {
range: 970..971,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 974..975,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 998..1098,
subject: Name(
ExprName {
range: 1004..1005,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 1011..1037,
pattern: MatchMapping(
PatternMatchMapping {
range: 1016..1022,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 1017..1018,
value: Int(
1,
),
},
),
],
patterns: [
MatchValue(
PatternMatchValue {
range: 1020..1021,
value: NumberLiteral(
ExprNumberLiteral {
range: 1020..1021,
value: Int(
0,
),
},
),
},
),
],
rest: None,
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1032..1037,
targets: [
Name(
ExprName {
range: 1032..1033,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1036..1037,
value: Int(
0,
),
},
),
},
),
],
},
MatchCase {
range: 1042..1068,
pattern: MatchMapping(
PatternMatchMapping {
range: 1047..1053,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 1048..1049,
value: Int(
0,
),
},
),
],
patterns: [
MatchValue(
PatternMatchValue {
range: 1051..1052,
value: NumberLiteral(
ExprNumberLiteral {
range: 1051..1052,
value: Int(
0,
),
},
),
},
),
],
rest: None,
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1063..1068,
targets: [
Name(
ExprName {
range: 1063..1064,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1067..1068,
value: Int(
1,
),
},
),
},
),
],
},
MatchCase {
range: 1073..1098,
pattern: MatchMapping(
PatternMatchMapping {
range: 1078..1083,
keys: [],
patterns: [],
rest: Some(
Identifier {
id: Name("z"),
range: 1081..1082,
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1093..1098,
targets: [
Name(
ExprName {
range: 1093..1094,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1097..1098,
value: Int(
2,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1121..1162,
subject: Call(
ExprCall {
range: 1127..1132,
func: Name(
ExprName {
range: 1127..1130,
id: Name("Seq"),
ctx: Load,
},
),
arguments: Arguments {
range: 1130..1132,
args: [],
keywords: [],
},
},
),
cases: [
MatchCase {
range: 1138..1162,
pattern: MatchSequence(
PatternMatchSequence {
range: 1143..1147,
patterns: [
MatchStar(
PatternMatchStar {
range: 1144..1146,
name: None,
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1157..1162,
targets: [
Name(
ExprName {
range: 1157..1158,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1161..1162,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1185..1245,
subject: Name(
ExprName {
range: 1191..1192,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 1198..1219,
pattern: MatchValue(
PatternMatchValue {
range: 1203..1204,
value: NumberLiteral(
ExprNumberLiteral {
range: 1203..1204,
value: Int(
1,
),
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1214..1219,
targets: [
Name(
ExprName {
range: 1214..1215,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1218..1219,
value: Int(
0,
),
},
),
},
),
],
},
MatchCase {
range: 1224..1245,
pattern: MatchValue(
PatternMatchValue {
range: 1229..1230,
value: NumberLiteral(
ExprNumberLiteral {
range: 1229..1230,
value: Int(
1,
),
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1240..1245,
targets: [
Name(
ExprName {
range: 1240..1241,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1244..1245,
value: Int(
1,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1268..1315,
subject: Name(
ExprName {
range: 1274..1275,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 1281..1315,
pattern: MatchMapping(
PatternMatchMapping {
range: 1286..1298,
keys: [
StringLiteral(
ExprStringLiteral {
range: 1287..1292,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 1287..1292,
value: "foo",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
],
patterns: [
MatchAs(
PatternMatchAs {
range: 1294..1297,
pattern: None,
name: Some(
Identifier {
id: Name("bar"),
range: 1294..1297,
},
),
},
),
],
rest: None,
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1308..1315,
targets: [
Name(
ExprName {
range: 1308..1309,
id: Name("y"),
ctx: Store,
},
),
],
value: Name(
ExprName {
range: 1312..1315,
id: Name("bar"),
ctx: Load,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1338..1392,
subject: Tuple(
ExprTuple {
range: 1344..1353,
elts: [
NumberLiteral(
ExprNumberLiteral {
range: 1345..1346,
value: Int(
0,
),
},
),
NumberLiteral(
ExprNumberLiteral {
range: 1348..1349,
value: Int(
1,
),
},
),
NumberLiteral(
ExprNumberLiteral {
range: 1351..1352,
value: Int(
2,
),
},
),
],
ctx: Load,
parenthesized: true,
},
),
cases: [
MatchCase {
range: 1359..1392,
pattern: MatchSequence(
PatternMatchSequence {
range: 1364..1377,
patterns: [
MatchValue(
PatternMatchValue {
range: 1365..1366,
value: NumberLiteral(
ExprNumberLiteral {
range: 1365..1366,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 1368..1369,
value: NumberLiteral(
ExprNumberLiteral {
range: 1368..1369,
value: Int(
1,
),
},
),
},
),
MatchStar(
PatternMatchStar {
range: 1371..1373,
name: Some(
Identifier {
id: Name("x"),
range: 1372..1373,
},
),
},
),
MatchValue(
PatternMatchValue {
range: 1375..1376,
value: NumberLiteral(
ExprNumberLiteral {
range: 1375..1376,
value: Int(
2,
),
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1387..1392,
targets: [
Name(
ExprName {
range: 1387..1388,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1391..1392,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1415..1529,
subject: Name(
ExprName {
range: 1421..1422,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 1428..1451,
pattern: MatchSequence(
PatternMatchSequence {
range: 1433..1436,
patterns: [
MatchValue(
PatternMatchValue {
range: 1434..1435,
value: NumberLiteral(
ExprNumberLiteral {
range: 1434..1435,
value: Int(
0,
),
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1446..1451,
targets: [
Name(
ExprName {
range: 1446..1447,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1450..1451,
value: Int(
0,
),
},
),
},
),
],
},
MatchCase {
range: 1456..1498,
pattern: MatchSequence(
PatternMatchSequence {
range: 1461..1467,
patterns: [
MatchValue(
PatternMatchValue {
range: 1462..1463,
value: NumberLiteral(
ExprNumberLiteral {
range: 1462..1463,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 1465..1466,
value: NumberLiteral(
ExprNumberLiteral {
range: 1465..1466,
value: Int(
0,
),
},
),
},
),
],
},
),
guard: Some(
Named(
ExprNamed {
range: 1472..1482,
target: Name(
ExprName {
range: 1472..1473,
id: Name("x"),
ctx: Store,
},
),
value: Subscript(
ExprSubscript {
range: 1477..1482,
value: Name(
ExprName {
range: 1477..1478,
id: Name("x"),
ctx: Load,
},
),
slice: Slice(
ExprSlice {
range: 1479..1481,
lower: None,
upper: Some(
NumberLiteral(
ExprNumberLiteral {
range: 1480..1481,
value: Int(
0,
),
},
),
),
step: None,
},
),
ctx: Load,
},
),
},
),
),
body: [
Assign(
StmtAssign {
range: 1493..1498,
targets: [
Name(
ExprName {
range: 1493..1494,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1497..1498,
value: Int(
1,
),
},
),
},
),
],
},
MatchCase {
range: 1503..1529,
pattern: MatchSequence(
PatternMatchSequence {
range: 1508..1514,
patterns: [
MatchValue(
PatternMatchValue {
range: 1509..1510,
value: NumberLiteral(
ExprNumberLiteral {
range: 1509..1510,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 1512..1513,
value: NumberLiteral(
ExprNumberLiteral {
range: 1512..1513,
value: Int(
0,
),
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1524..1529,
targets: [
Name(
ExprName {
range: 1524..1525,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1528..1529,
value: Int(
2,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1552..1595,
subject: Name(
ExprName {
range: 1558..1559,
id: Name("w"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 1565..1595,
pattern: MatchSequence(
PatternMatchSequence {
range: 1570..1580,
patterns: [
MatchAs(
PatternMatchAs {
range: 1571..1572,
pattern: None,
name: Some(
Identifier {
id: Name("x"),
range: 1571..1572,
},
),
},
),
MatchAs(
PatternMatchAs {
range: 1574..1575,
pattern: None,
name: Some(
Identifier {
id: Name("y"),
range: 1574..1575,
},
),
},
),
MatchStar(
PatternMatchStar {
range: 1577..1579,
name: None,
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1590..1595,
targets: [
Name(
ExprName {
range: 1590..1591,
id: Name("z"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1594..1595,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1618..1664,
subject: Name(
ExprName {
range: 1624..1625,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 1631..1664,
pattern: MatchValue(
PatternMatchValue {
range: 1636..1649,
value: BinOp(
ExprBinOp {
range: 1636..1649,
left: UnaryOp(
ExprUnaryOp {
range: 1636..1641,
op: USub,
operand: NumberLiteral(
ExprNumberLiteral {
range: 1637..1641,
value: Float(
0.25,
),
},
),
},
),
op: Sub,
right: NumberLiteral(
ExprNumberLiteral {
range: 1644..1649,
value: Complex {
real: 0.0,
imag: 1.75,
},
},
),
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1659..1664,
targets: [
Name(
ExprName {
range: 1659..1660,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1663..1664,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1687..1726,
subject: Tuple(
ExprTuple {
range: 1693..1697,
elts: [
Name(
ExprName {
range: 1694..1695,
id: Name("x"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: true,
},
),
cases: [
MatchCase {
range: 1703..1726,
pattern: MatchSequence(
PatternMatchSequence {
range: 1708..1711,
patterns: [
MatchAs(
PatternMatchAs {
range: 1709..1710,
pattern: None,
name: Some(
Identifier {
id: Name("y"),
range: 1709..1710,
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1721..1726,
targets: [
Name(
ExprName {
range: 1721..1722,
id: Name("z"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1725..1726,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1749..1789,
subject: Name(
ExprName {
range: 1755..1756,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 1762..1789,
pattern: MatchValue(
PatternMatchValue {
range: 1767..1774,
value: Attribute(
ExprAttribute {
range: 1767..1774,
value: Attribute(
ExprAttribute {
range: 1767..1772,
value: Attribute(
ExprAttribute {
range: 1767..1770,
value: Name(
ExprName {
range: 1767..1768,
id: Name("A"),
ctx: Load,
},
),
attr: Identifier {
id: Name("B"),
range: 1769..1770,
},
ctx: Load,
},
),
attr: Identifier {
id: Name("C"),
range: 1771..1772,
},
ctx: Load,
},
),
attr: Identifier {
id: Name("D"),
range: 1773..1774,
},
ctx: Load,
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1784..1789,
targets: [
Name(
ExprName {
range: 1784..1785,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1788..1789,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1812..1849,
subject: Name(
ExprName {
range: 1818..1819,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 1825..1849,
pattern: MatchSingleton(
PatternMatchSingleton {
range: 1830..1834,
value: None,
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1844..1849,
targets: [
Name(
ExprName {
range: 1844..1845,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1848..1849,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1872..1906,
subject: Name(
ExprName {
range: 1878..1879,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 1885..1906,
pattern: MatchValue(
PatternMatchValue {
range: 1890..1891,
value: NumberLiteral(
ExprNumberLiteral {
range: 1890..1891,
value: Int(
0,
),
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1901..1906,
targets: [
Name(
ExprName {
range: 1901..1902,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1905..1906,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1929..1967,
subject: Name(
ExprName {
range: 1935..1936,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 1942..1967,
pattern: MatchSingleton(
PatternMatchSingleton {
range: 1947..1952,
value: False,
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 1962..1967,
targets: [
Name(
ExprName {
range: 1962..1963,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 1966..1967,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 1990..2081,
subject: Name(
ExprName {
range: 1996..1997,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 2003..2025,
pattern: MatchSequence(
PatternMatchSequence {
range: 2008..2010,
patterns: [],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2020..2025,
targets: [
Name(
ExprName {
range: 2020..2021,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2024..2025,
value: Int(
0,
),
},
),
},
),
],
},
MatchCase {
range: 2030..2054,
pattern: MatchSequence(
PatternMatchSequence {
range: 2035..2039,
patterns: [
MatchValue(
PatternMatchValue {
range: 2036..2038,
value: StringLiteral(
ExprStringLiteral {
range: 2036..2038,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 2036..2038,
value: "",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2049..2054,
targets: [
Name(
ExprName {
range: 2049..2050,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2053..2054,
value: Int(
1,
),
},
),
},
),
],
},
MatchCase {
range: 2059..2081,
pattern: MatchValue(
PatternMatchValue {
range: 2064..2066,
value: StringLiteral(
ExprStringLiteral {
range: 2064..2066,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 2064..2066,
value: "",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2076..2081,
targets: [
Name(
ExprName {
range: 2076..2077,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2080..2081,
value: Int(
2,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2104..2138,
subject: Name(
ExprName {
range: 2110..2111,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 2117..2138,
pattern: MatchAs(
PatternMatchAs {
range: 2122..2123,
pattern: None,
name: Some(
Identifier {
id: Name("z"),
range: 2122..2123,
},
),
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2133..2138,
targets: [
Name(
ExprName {
range: 2133..2134,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2137..2138,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2161..2207,
subject: Name(
ExprName {
range: 2167..2168,
id: Name("w"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 2174..2207,
pattern: MatchSequence(
PatternMatchSequence {
range: 2179..2192,
patterns: [
MatchAs(
PatternMatchAs {
range: 2180..2181,
pattern: None,
name: Some(
Identifier {
id: Name("x"),
range: 2180..2181,
},
),
},
),
MatchAs(
PatternMatchAs {
range: 2183..2184,
pattern: None,
name: Some(
Identifier {
id: Name("y"),
range: 2183..2184,
},
),
},
),
MatchStar(
PatternMatchStar {
range: 2186..2191,
name: Some(
Identifier {
id: Name("rest"),
range: 2187..2191,
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2202..2207,
targets: [
Name(
ExprName {
range: 2202..2203,
id: Name("z"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2206..2207,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2230..2307,
subject: Name(
ExprName {
range: 2236..2237,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 2243..2307,
pattern: MatchOr(
PatternMatchOr {
range: 2248..2278,
patterns: [
MatchAs(
PatternMatchAs {
range: 2249..2255,
pattern: Some(
MatchValue(
PatternMatchValue {
range: 2249..2250,
value: NumberLiteral(
ExprNumberLiteral {
range: 2249..2250,
value: Int(
0,
),
},
),
},
),
),
name: Some(
Identifier {
id: Name("z"),
range: 2254..2255,
},
),
},
),
MatchAs(
PatternMatchAs {
range: 2260..2266,
pattern: Some(
MatchValue(
PatternMatchValue {
range: 2260..2261,
value: NumberLiteral(
ExprNumberLiteral {
range: 2260..2261,
value: Int(
1,
),
},
),
},
),
),
name: Some(
Identifier {
id: Name("z"),
range: 2265..2266,
},
),
},
),
MatchAs(
PatternMatchAs {
range: 2271..2277,
pattern: Some(
MatchValue(
PatternMatchValue {
range: 2271..2272,
value: NumberLiteral(
ExprNumberLiteral {
range: 2271..2272,
value: Int(
2,
),
},
),
},
),
),
name: Some(
Identifier {
id: Name("z"),
range: 2276..2277,
},
),
},
),
],
},
),
guard: Some(
Compare(
ExprCompare {
range: 2282..2292,
left: Name(
ExprName {
range: 2282..2283,
id: Name("z"),
ctx: Load,
},
),
ops: [
Eq,
],
comparators: [
BinOp(
ExprBinOp {
range: 2287..2292,
left: Name(
ExprName {
range: 2287..2288,
id: Name("x"),
ctx: Load,
},
),
op: Mod,
right: NumberLiteral(
ExprNumberLiteral {
range: 2291..2292,
value: Int(
2,
),
},
),
},
),
],
},
),
),
body: [
Assign(
StmtAssign {
range: 2302..2307,
targets: [
Name(
ExprName {
range: 2302..2303,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2306..2307,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2330..2499,
subject: Name(
ExprName {
range: 2336..2337,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 2343..2378,
pattern: MatchMapping(
PatternMatchMapping {
range: 2348..2363,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 2349..2350,
value: Int(
0,
),
},
),
],
patterns: [
MatchSequence(
PatternMatchSequence {
range: 2352..2362,
patterns: [
MatchValue(
PatternMatchValue {
range: 2353..2354,
value: NumberLiteral(
ExprNumberLiteral {
range: 2353..2354,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 2356..2357,
value: NumberLiteral(
ExprNumberLiteral {
range: 2356..2357,
value: Int(
2,
),
},
),
},
),
MatchMapping(
PatternMatchMapping {
range: 2359..2361,
keys: [],
patterns: [],
rest: None,
},
),
],
},
),
],
rest: None,
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2373..2378,
targets: [
Name(
ExprName {
range: 2373..2374,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2377..2378,
value: Int(
0,
),
},
),
},
),
],
},
MatchCase {
range: 2383..2472,
pattern: MatchOr(
PatternMatchOr {
range: 2388..2457,
patterns: [
MatchMapping(
PatternMatchMapping {
range: 2388..2411,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 2389..2390,
value: Int(
0,
),
},
),
],
patterns: [
MatchOr(
PatternMatchOr {
range: 2392..2410,
patterns: [
MatchSequence(
PatternMatchSequence {
range: 2392..2402,
patterns: [
MatchValue(
PatternMatchValue {
range: 2393..2394,
value: NumberLiteral(
ExprNumberLiteral {
range: 2393..2394,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 2396..2397,
value: NumberLiteral(
ExprNumberLiteral {
range: 2396..2397,
value: Int(
2,
),
},
),
},
),
MatchMapping(
PatternMatchMapping {
range: 2399..2401,
keys: [],
patterns: [],
rest: None,
},
),
],
},
),
MatchSingleton(
PatternMatchSingleton {
range: 2405..2410,
value: False,
},
),
],
},
),
],
rest: None,
},
),
MatchMapping(
PatternMatchMapping {
range: 2414..2423,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 2415..2416,
value: Int(
1,
),
},
),
],
patterns: [
MatchSequence(
PatternMatchSequence {
range: 2418..2422,
patterns: [
MatchSequence(
PatternMatchSequence {
range: 2419..2421,
patterns: [],
},
),
],
},
),
],
rest: None,
},
),
MatchMapping(
PatternMatchMapping {
range: 2426..2441,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 2427..2428,
value: Int(
0,
),
},
),
],
patterns: [
MatchSequence(
PatternMatchSequence {
range: 2430..2440,
patterns: [
MatchValue(
PatternMatchValue {
range: 2431..2432,
value: NumberLiteral(
ExprNumberLiteral {
range: 2431..2432,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 2434..2435,
value: NumberLiteral(
ExprNumberLiteral {
range: 2434..2435,
value: Int(
2,
),
},
),
},
),
MatchMapping(
PatternMatchMapping {
range: 2437..2439,
keys: [],
patterns: [],
rest: None,
},
),
],
},
),
],
rest: None,
},
),
MatchSequence(
PatternMatchSequence {
range: 2444..2446,
patterns: [],
},
),
MatchValue(
PatternMatchValue {
range: 2449..2452,
value: StringLiteral(
ExprStringLiteral {
range: 2449..2452,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 2449..2452,
value: "X",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
},
),
MatchMapping(
PatternMatchMapping {
range: 2455..2457,
keys: [],
patterns: [],
rest: None,
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2467..2472,
targets: [
Name(
ExprName {
range: 2467..2468,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2471..2472,
value: Int(
1,
),
},
),
},
),
],
},
MatchCase {
range: 2477..2499,
pattern: MatchSequence(
PatternMatchSequence {
range: 2482..2484,
patterns: [],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2494..2499,
targets: [
Name(
ExprName {
range: 2494..2495,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2498..2499,
value: Int(
2,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2522..2568,
subject: Tuple(
ExprTuple {
range: 2528..2537,
elts: [
NumberLiteral(
ExprNumberLiteral {
range: 2529..2530,
value: Int(
0,
),
},
),
NumberLiteral(
ExprNumberLiteral {
range: 2532..2533,
value: Int(
1,
),
},
),
NumberLiteral(
ExprNumberLiteral {
range: 2535..2536,
value: Int(
2,
),
},
),
],
ctx: Load,
parenthesized: true,
},
),
cases: [
MatchCase {
range: 2543..2568,
pattern: MatchSequence(
PatternMatchSequence {
range: 2548..2553,
patterns: [
MatchValue(
PatternMatchValue {
range: 2548..2549,
value: NumberLiteral(
ExprNumberLiteral {
range: 2548..2549,
value: Int(
0,
),
},
),
},
),
MatchStar(
PatternMatchStar {
range: 2551..2553,
name: Some(
Identifier {
id: Name("x"),
range: 2552..2553,
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2563..2568,
targets: [
Name(
ExprName {
range: 2563..2564,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2567..2568,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2591..2638,
subject: Tuple(
ExprTuple {
range: 2597..2606,
elts: [
NumberLiteral(
ExprNumberLiteral {
range: 2598..2599,
value: Int(
0,
),
},
),
NumberLiteral(
ExprNumberLiteral {
range: 2601..2602,
value: Int(
1,
),
},
),
NumberLiteral(
ExprNumberLiteral {
range: 2604..2605,
value: Int(
2,
),
},
),
],
ctx: Load,
parenthesized: true,
},
),
cases: [
MatchCase {
range: 2612..2638,
pattern: MatchSequence(
PatternMatchSequence {
range: 2617..2623,
patterns: [
MatchStar(
PatternMatchStar {
range: 2617..2619,
name: Some(
Identifier {
id: Name("x"),
range: 2618..2619,
},
),
},
),
MatchValue(
PatternMatchValue {
range: 2621..2622,
value: NumberLiteral(
ExprNumberLiteral {
range: 2621..2622,
value: Int(
2,
),
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2633..2638,
targets: [
Name(
ExprName {
range: 2633..2634,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2637..2638,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2661..2697,
subject: Tuple(
ExprTuple {
range: 2667..2669,
elts: [
Name(
ExprName {
range: 2667..2668,
id: Name("x"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
cases: [
MatchCase {
range: 2675..2697,
pattern: MatchSequence(
PatternMatchSequence {
range: 2680..2682,
patterns: [
MatchAs(
PatternMatchAs {
range: 2680..2681,
pattern: None,
name: Some(
Identifier {
id: Name("y"),
range: 2680..2681,
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2692..2697,
targets: [
Name(
ExprName {
range: 2692..2693,
id: Name("z"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2696..2697,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2720..2760,
subject: Tuple(
ExprTuple {
range: 2726..2730,
elts: [
Name(
ExprName {
range: 2726..2727,
id: Name("w"),
ctx: Load,
},
),
Name(
ExprName {
range: 2729..2730,
id: Name("x"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
cases: [
MatchCase {
range: 2736..2760,
pattern: MatchSequence(
PatternMatchSequence {
range: 2741..2745,
patterns: [
MatchAs(
PatternMatchAs {
range: 2741..2742,
pattern: None,
name: Some(
Identifier {
id: Name("y"),
range: 2741..2742,
},
),
},
),
MatchAs(
PatternMatchAs {
range: 2744..2745,
pattern: None,
name: Some(
Identifier {
id: Name("z"),
range: 2744..2745,
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2755..2760,
targets: [
Name(
ExprName {
range: 2755..2756,
id: Name("v"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2759..2760,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2783..2829,
subject: Tuple(
ExprTuple {
range: 2789..2796,
elts: [
Named(
ExprNamed {
range: 2789..2795,
target: Name(
ExprName {
range: 2789..2790,
id: Name("w"),
ctx: Store,
},
),
value: Name(
ExprName {
range: 2794..2795,
id: Name("x"),
ctx: Load,
},
),
},
),
],
ctx: Load,
parenthesized: false,
},
),
cases: [
MatchCase {
range: 2802..2829,
pattern: MatchSequence(
PatternMatchSequence {
range: 2807..2814,
patterns: [
MatchAs(
PatternMatchAs {
range: 2807..2813,
pattern: Some(
MatchAs(
PatternMatchAs {
range: 2807..2808,
pattern: None,
name: Some(
Identifier {
id: Name("y"),
range: 2807..2808,
},
),
},
),
),
name: Some(
Identifier {
id: Name("v"),
range: 2812..2813,
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 2824..2829,
targets: [
Name(
ExprName {
range: 2824..2825,
id: Name("z"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 2828..2829,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2831..2952,
subject: Name(
ExprName {
range: 2837..2838,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 2927..2952,
pattern: MatchValue(
PatternMatchValue {
range: 2932..2938,
value: FString(
ExprFString {
range: 2932..2938,
value: FStringValue {
inner: Single(
FString(
FString {
range: 2932..2938,
elements: [
Expression(
FStringExpressionElement {
range: 2934..2937,
expression: Name(
ExprName {
range: 2935..2936,
id: Name("y"),
ctx: Load,
},
),
debug_text: None,
conversion: None,
format_spec: None,
},
),
],
flags: FStringFlags {
quote_style: Double,
prefix: Regular,
triple_quoted: false,
},
},
),
),
},
},
),
},
),
guard: None,
body: [
Pass(
StmtPass {
range: 2948..2952,
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 2953..3025,
subject: Dict(
ExprDict {
range: 2959..2970,
items: [
DictItem {
key: Some(
StringLiteral(
ExprStringLiteral {
range: 2960..2966,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 2960..2966,
value: "test",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
),
value: NumberLiteral(
ExprNumberLiteral {
range: 2968..2969,
value: Int(
1,
),
},
),
},
],
},
),
cases: [
MatchCase {
range: 2976..3025,
pattern: MatchMapping(
PatternMatchMapping {
range: 2981..3004,
keys: [],
patterns: [],
rest: Some(
Identifier {
id: Name("rest"),
range: 2993..2997,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3014..3025,
value: Call(
ExprCall {
range: 3014..3025,
func: Name(
ExprName {
range: 3014..3019,
id: Name("print"),
ctx: Load,
},
),
arguments: Arguments {
range: 3019..3025,
args: [
Name(
ExprName {
range: 3020..3024,
id: Name("rest"),
ctx: Load,
},
),
],
keywords: [],
},
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3026..3129,
subject: Dict(
ExprDict {
range: 3032..3049,
items: [
DictItem {
key: Some(
StringLiteral(
ExprStringLiteral {
range: 3033..3040,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 3033..3040,
value: "label",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
),
value: StringLiteral(
ExprStringLiteral {
range: 3042..3048,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 3042..3048,
value: "test",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
},
],
},
),
cases: [
MatchCase {
range: 3055..3129,
pattern: MatchMapping(
PatternMatchMapping {
range: 3060..3107,
keys: [
StringLiteral(
ExprStringLiteral {
range: 3070..3077,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 3070..3077,
value: "label",
flags: StringLiteralFlags {
quote_style: Double,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
],
patterns: [
MatchAs(
PatternMatchAs {
range: 3079..3100,
pattern: Some(
MatchOr(
PatternMatchOr {
range: 3079..3091,
patterns: [
MatchClass(
PatternMatchClass {
range: 3079..3084,
cls: Name(
ExprName {
range: 3079..3082,
id: Name("str"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 3082..3084,
patterns: [],
keywords: [],
},
},
),
MatchSingleton(
PatternMatchSingleton {
range: 3087..3091,
value: None,
},
),
],
},
),
),
name: Some(
Identifier {
id: Name("label"),
range: 3095..3100,
},
),
},
),
],
rest: None,
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3117..3129,
value: Call(
ExprCall {
range: 3117..3129,
func: Name(
ExprName {
range: 3117..3122,
id: Name("print"),
ctx: Load,
},
),
arguments: Arguments {
range: 3122..3129,
args: [
Name(
ExprName {
range: 3123..3128,
id: Name("label"),
ctx: Load,
},
),
],
keywords: [],
},
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3130..3170,
subject: Name(
ExprName {
range: 3136..3137,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 3143..3170,
pattern: MatchSequence(
PatternMatchSequence {
range: 3148..3155,
patterns: [
MatchValue(
PatternMatchValue {
range: 3149..3150,
value: NumberLiteral(
ExprNumberLiteral {
range: 3149..3150,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 3152..3153,
value: NumberLiteral(
ExprNumberLiteral {
range: 3152..3153,
value: Int(
1,
),
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 3165..3170,
targets: [
Name(
ExprName {
range: 3165..3166,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 3169..3170,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3171..3211,
subject: Name(
ExprName {
range: 3177..3178,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 3184..3211,
pattern: MatchSequence(
PatternMatchSequence {
range: 3189..3196,
patterns: [
MatchValue(
PatternMatchValue {
range: 3190..3191,
value: NumberLiteral(
ExprNumberLiteral {
range: 3190..3191,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 3193..3194,
value: NumberLiteral(
ExprNumberLiteral {
range: 3193..3194,
value: Int(
1,
),
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 3206..3211,
targets: [
Name(
ExprName {
range: 3206..3207,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 3210..3211,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3212..3249,
subject: Name(
ExprName {
range: 3218..3219,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 3225..3249,
pattern: MatchSequence(
PatternMatchSequence {
range: 3230..3234,
patterns: [
MatchValue(
PatternMatchValue {
range: 3231..3232,
value: NumberLiteral(
ExprNumberLiteral {
range: 3231..3232,
value: Int(
0,
),
},
),
},
),
],
},
),
guard: None,
body: [
Assign(
StmtAssign {
range: 3244..3249,
targets: [
Name(
ExprName {
range: 3244..3245,
id: Name("y"),
ctx: Store,
},
),
],
value: NumberLiteral(
ExprNumberLiteral {
range: 3248..3249,
value: Int(
0,
),
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3250..3284,
subject: Tuple(
ExprTuple {
range: 3256..3258,
elts: [
Name(
ExprName {
range: 3256..3257,
id: Name("x"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
cases: [
MatchCase {
range: 3264..3284,
pattern: MatchAs(
PatternMatchAs {
range: 3269..3270,
pattern: None,
name: Some(
Identifier {
id: Name("z"),
range: 3269..3270,
},
),
},
),
guard: None,
body: [
Pass(
StmtPass {
range: 3280..3284,
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3285..3321,
subject: Tuple(
ExprTuple {
range: 3291..3295,
elts: [
Name(
ExprName {
range: 3291..3292,
id: Name("x"),
ctx: Load,
},
),
Name(
ExprName {
range: 3294..3295,
id: Name("y"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
cases: [
MatchCase {
range: 3301..3321,
pattern: MatchAs(
PatternMatchAs {
range: 3306..3307,
pattern: None,
name: Some(
Identifier {
id: Name("z"),
range: 3306..3307,
},
),
},
),
guard: None,
body: [
Pass(
StmtPass {
range: 3317..3321,
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3322..3359,
subject: Tuple(
ExprTuple {
range: 3328..3333,
elts: [
Name(
ExprName {
range: 3328..3329,
id: Name("x"),
ctx: Load,
},
),
Name(
ExprName {
range: 3331..3332,
id: Name("y"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
cases: [
MatchCase {
range: 3339..3359,
pattern: MatchAs(
PatternMatchAs {
range: 3344..3345,
pattern: None,
name: Some(
Identifier {
id: Name("z"),
range: 3344..3345,
},
),
},
),
guard: None,
body: [
Pass(
StmtPass {
range: 3355..3359,
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3385..3475,
subject: Name(
ExprName {
range: 3391..3392,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 3398..3420,
pattern: MatchSingleton(
PatternMatchSingleton {
range: 3403..3407,
value: None,
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3417..3420,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3417..3420,
},
),
},
),
],
},
MatchCase {
range: 3425..3447,
pattern: MatchSingleton(
PatternMatchSingleton {
range: 3430..3434,
value: True,
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3444..3447,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3444..3447,
},
),
},
),
],
},
MatchCase {
range: 3452..3475,
pattern: MatchSingleton(
PatternMatchSingleton {
range: 3457..3462,
value: False,
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3472..3475,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3472..3475,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3497..3821,
subject: Name(
ExprName {
range: 3503..3504,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 3510..3531,
pattern: MatchValue(
PatternMatchValue {
range: 3515..3518,
value: Attribute(
ExprAttribute {
range: 3515..3518,
value: Name(
ExprName {
range: 3515..3516,
id: Name("a"),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 3517..3518,
},
ctx: Load,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3528..3531,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3528..3531,
},
),
},
),
],
},
MatchCase {
range: 3536..3559,
pattern: MatchValue(
PatternMatchValue {
range: 3541..3546,
value: Attribute(
ExprAttribute {
range: 3541..3546,
value: Attribute(
ExprAttribute {
range: 3541..3544,
value: Name(
ExprName {
range: 3541..3542,
id: Name("a"),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 3543..3544,
},
ctx: Load,
},
),
attr: Identifier {
id: Name("c"),
range: 3545..3546,
},
ctx: Load,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3556..3559,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3556..3559,
},
),
},
),
],
},
MatchCase {
range: 3564..3584,
pattern: MatchValue(
PatternMatchValue {
range: 3569..3571,
value: StringLiteral(
ExprStringLiteral {
range: 3569..3571,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 3569..3571,
value: "",
flags: StringLiteralFlags {
quote_style: Single,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3581..3584,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3581..3584,
},
),
},
),
],
},
MatchCase {
range: 3589..3610,
pattern: MatchValue(
PatternMatchValue {
range: 3594..3597,
value: BytesLiteral(
ExprBytesLiteral {
range: 3594..3597,
value: BytesLiteralValue {
inner: Single(
BytesLiteral {
range: 3594..3597,
value: [],
flags: BytesLiteralFlags {
quote_style: Single,
prefix: Regular,
triple_quoted: false,
},
},
),
},
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3607..3610,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3607..3610,
},
),
},
),
],
},
MatchCase {
range: 3615..3634,
pattern: MatchValue(
PatternMatchValue {
range: 3620..3621,
value: NumberLiteral(
ExprNumberLiteral {
range: 3620..3621,
value: Int(
1,
),
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3631..3634,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3631..3634,
},
),
},
),
],
},
MatchCase {
range: 3639..3660,
pattern: MatchValue(
PatternMatchValue {
range: 3644..3647,
value: NumberLiteral(
ExprNumberLiteral {
range: 3644..3647,
value: Float(
1.0,
),
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3657..3660,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3657..3660,
},
),
},
),
],
},
MatchCase {
range: 3665..3687,
pattern: MatchValue(
PatternMatchValue {
range: 3670..3674,
value: NumberLiteral(
ExprNumberLiteral {
range: 3670..3674,
value: Complex {
real: 0.0,
imag: 1.0,
},
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3684..3687,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3684..3687,
},
),
},
),
],
},
MatchCase {
range: 3692..3716,
pattern: MatchValue(
PatternMatchValue {
range: 3697..3703,
value: BinOp(
ExprBinOp {
range: 3697..3703,
left: NumberLiteral(
ExprNumberLiteral {
range: 3697..3698,
value: Int(
1,
),
},
),
op: Add,
right: NumberLiteral(
ExprNumberLiteral {
range: 3701..3703,
value: Complex {
real: 0.0,
imag: 1.0,
},
},
),
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3713..3716,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3713..3716,
},
),
},
),
],
},
MatchCase {
range: 3721..3741,
pattern: MatchValue(
PatternMatchValue {
range: 3726..3728,
value: UnaryOp(
ExprUnaryOp {
range: 3726..3728,
op: USub,
operand: NumberLiteral(
ExprNumberLiteral {
range: 3727..3728,
value: Int(
1,
),
},
),
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3738..3741,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3738..3741,
},
),
},
),
],
},
MatchCase {
range: 3746..3767,
pattern: MatchValue(
PatternMatchValue {
range: 3751..3754,
value: UnaryOp(
ExprUnaryOp {
range: 3751..3754,
op: USub,
operand: NumberLiteral(
ExprNumberLiteral {
range: 3752..3754,
value: Float(
1.0,
),
},
),
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3764..3767,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3764..3767,
},
),
},
),
],
},
MatchCase {
range: 3772..3795,
pattern: MatchValue(
PatternMatchValue {
range: 3777..3782,
value: UnaryOp(
ExprUnaryOp {
range: 3777..3782,
op: USub,
operand: NumberLiteral(
ExprNumberLiteral {
range: 3778..3782,
value: Int(
1,
),
},
),
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3792..3795,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3792..3795,
},
),
},
),
],
},
MatchCase {
range: 3800..3821,
pattern: MatchValue(
PatternMatchValue {
range: 3806..3807,
value: NumberLiteral(
ExprNumberLiteral {
range: 3806..3807,
value: Int(
1,
),
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3818..3821,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3818..3821,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3840..3927,
subject: Name(
ExprName {
range: 3846..3847,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 3853..3876,
pattern: MatchOr(
PatternMatchOr {
range: 3858..3863,
patterns: [
MatchValue(
PatternMatchValue {
range: 3858..3859,
value: NumberLiteral(
ExprNumberLiteral {
range: 3858..3859,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 3862..3863,
value: NumberLiteral(
ExprNumberLiteral {
range: 3862..3863,
value: Int(
2,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3873..3876,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3873..3876,
},
),
},
),
],
},
MatchCase {
range: 3881..3927,
pattern: MatchOr(
PatternMatchOr {
range: 3886..3914,
patterns: [
MatchValue(
PatternMatchValue {
range: 3886..3888,
value: StringLiteral(
ExprStringLiteral {
range: 3886..3888,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 3886..3888,
value: "",
flags: StringLiteralFlags {
quote_style: Single,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
},
),
MatchValue(
PatternMatchValue {
range: 3891..3894,
value: NumberLiteral(
ExprNumberLiteral {
range: 3891..3894,
value: Float(
1.1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 3897..3899,
value: UnaryOp(
ExprUnaryOp {
range: 3897..3899,
op: USub,
operand: NumberLiteral(
ExprNumberLiteral {
range: 3898..3899,
value: Int(
1,
),
},
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 3902..3908,
value: BinOp(
ExprBinOp {
range: 3902..3908,
left: NumberLiteral(
ExprNumberLiteral {
range: 3902..3903,
value: Int(
1,
),
},
),
op: Add,
right: NumberLiteral(
ExprNumberLiteral {
range: 3906..3908,
value: Complex {
real: 0.0,
imag: 1.0,
},
},
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 3911..3914,
value: Attribute(
ExprAttribute {
range: 3911..3914,
value: Name(
ExprName {
range: 3911..3912,
id: Name("a"),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 3913..3914,
},
ctx: Load,
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3924..3927,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3924..3927,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3946..4163,
subject: Name(
ExprName {
range: 3952..3953,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 3959..3978,
pattern: MatchAs(
PatternMatchAs {
range: 3964..3965,
pattern: None,
name: Some(
Identifier {
id: Name("a"),
range: 3964..3965,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 3975..3978,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 3975..3978,
},
),
},
),
],
},
MatchCase {
range: 3983..4007,
pattern: MatchAs(
PatternMatchAs {
range: 3988..3994,
pattern: Some(
MatchAs(
PatternMatchAs {
range: 3988..3989,
pattern: None,
name: Some(
Identifier {
id: Name("a"),
range: 3988..3989,
},
),
},
),
),
name: Some(
Identifier {
id: Name("b"),
range: 3993..3994,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4004..4007,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4004..4007,
},
),
},
),
],
},
MatchCase {
range: 4012..4042,
pattern: MatchAs(
PatternMatchAs {
range: 4017..4029,
pattern: Some(
MatchOr(
PatternMatchOr {
range: 4017..4022,
patterns: [
MatchValue(
PatternMatchValue {
range: 4017..4018,
value: NumberLiteral(
ExprNumberLiteral {
range: 4017..4018,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4021..4022,
value: NumberLiteral(
ExprNumberLiteral {
range: 4021..4022,
value: Int(
2,
),
},
),
},
),
],
},
),
),
name: Some(
Identifier {
id: Name("two"),
range: 4026..4029,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4039..4042,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4039..4042,
},
),
},
),
],
},
MatchCase {
range: 4047..4078,
pattern: MatchAs(
PatternMatchAs {
range: 4052..4065,
pattern: Some(
MatchValue(
PatternMatchValue {
range: 4052..4058,
value: BinOp(
ExprBinOp {
range: 4052..4058,
left: NumberLiteral(
ExprNumberLiteral {
range: 4052..4053,
value: Int(
1,
),
},
),
op: Add,
right: NumberLiteral(
ExprNumberLiteral {
range: 4056..4058,
value: Complex {
real: 0.0,
imag: 3.0,
},
},
),
},
),
},
),
),
name: Some(
Identifier {
id: Name("sum"),
range: 4062..4065,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4075..4078,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4075..4078,
},
),
},
),
],
},
MatchCase {
range: 4083..4110,
pattern: MatchAs(
PatternMatchAs {
range: 4088..4097,
pattern: Some(
MatchValue(
PatternMatchValue {
range: 4088..4091,
value: Attribute(
ExprAttribute {
range: 4088..4091,
value: Name(
ExprName {
range: 4088..4089,
id: Name("a"),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 4090..4091,
},
ctx: Load,
},
),
},
),
),
name: Some(
Identifier {
id: Name("ab"),
range: 4095..4097,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4107..4110,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4107..4110,
},
),
},
),
],
},
MatchCase {
range: 4115..4134,
pattern: MatchAs(
PatternMatchAs {
range: 4120..4121,
pattern: None,
name: None,
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4131..4134,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4131..4134,
},
),
},
),
],
},
MatchCase {
range: 4139..4163,
pattern: MatchAs(
PatternMatchAs {
range: 4144..4150,
pattern: Some(
MatchAs(
PatternMatchAs {
range: 4144..4145,
pattern: None,
name: None,
},
),
),
name: Some(
Identifier {
id: Name("x"),
range: 4149..4150,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4160..4163,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4160..4163,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 4188..4439,
subject: Name(
ExprName {
range: 4194..4195,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 4201..4226,
pattern: MatchSequence(
PatternMatchSequence {
range: 4206..4213,
patterns: [
MatchValue(
PatternMatchValue {
range: 4206..4207,
value: NumberLiteral(
ExprNumberLiteral {
range: 4206..4207,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4209..4210,
value: NumberLiteral(
ExprNumberLiteral {
range: 4209..4210,
value: Int(
2,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4212..4213,
value: NumberLiteral(
ExprNumberLiteral {
range: 4212..4213,
value: Int(
3,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4223..4226,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4223..4226,
},
),
},
),
],
},
MatchCase {
range: 4231..4259,
pattern: MatchSequence(
PatternMatchSequence {
range: 4236..4246,
patterns: [
MatchValue(
PatternMatchValue {
range: 4237..4238,
value: NumberLiteral(
ExprNumberLiteral {
range: 4237..4238,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4240..4241,
value: NumberLiteral(
ExprNumberLiteral {
range: 4240..4241,
value: Int(
2,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4243..4244,
value: NumberLiteral(
ExprNumberLiteral {
range: 4243..4244,
value: Int(
3,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4256..4259,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4256..4259,
},
),
},
),
],
},
MatchCase {
range: 4264..4304,
pattern: MatchSequence(
PatternMatchSequence {
range: 4269..4291,
patterns: [
MatchValue(
PatternMatchValue {
range: 4270..4276,
value: BinOp(
ExprBinOp {
range: 4270..4276,
left: NumberLiteral(
ExprNumberLiteral {
range: 4270..4271,
value: Int(
1,
),
},
),
op: Add,
right: NumberLiteral(
ExprNumberLiteral {
range: 4274..4276,
value: Complex {
real: 0.0,
imag: 2.0,
},
},
),
},
),
},
),
MatchAs(
PatternMatchAs {
range: 4278..4279,
pattern: None,
name: Some(
Identifier {
id: Name("a"),
range: 4278..4279,
},
),
},
),
MatchSingleton(
PatternMatchSingleton {
range: 4281..4285,
value: None,
},
),
MatchValue(
PatternMatchValue {
range: 4287..4290,
value: Attribute(
ExprAttribute {
range: 4287..4290,
value: Name(
ExprName {
range: 4287..4288,
id: Name("a"),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 4289..4290,
},
ctx: Load,
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4301..4304,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4301..4304,
},
),
},
),
],
},
MatchCase {
range: 4309..4343,
pattern: MatchAs(
PatternMatchAs {
range: 4314..4330,
pattern: Some(
MatchSequence(
PatternMatchSequence {
range: 4314..4325,
patterns: [
MatchAs(
PatternMatchAs {
range: 4315..4321,
pattern: Some(
MatchValue(
PatternMatchValue {
range: 4315..4316,
value: NumberLiteral(
ExprNumberLiteral {
range: 4315..4316,
value: Int(
1,
),
},
),
},
),
),
name: Some(
Identifier {
id: Name("X"),
range: 4320..4321,
},
),
},
),
MatchAs(
PatternMatchAs {
range: 4323..4324,
pattern: None,
name: Some(
Identifier {
id: Name("b"),
range: 4323..4324,
},
),
},
),
],
},
),
),
name: Some(
Identifier {
id: Name("S"),
range: 4329..4330,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4340..4343,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4340..4343,
},
),
},
),
],
},
MatchCase {
range: 4348..4380,
pattern: MatchSequence(
PatternMatchSequence {
range: 4353..4367,
patterns: [
MatchValue(
PatternMatchValue {
range: 4354..4355,
value: NumberLiteral(
ExprNumberLiteral {
range: 4354..4355,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4357..4358,
value: NumberLiteral(
ExprNumberLiteral {
range: 4357..4358,
value: Int(
2,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4360..4366,
value: BinOp(
ExprBinOp {
range: 4360..4366,
left: NumberLiteral(
ExprNumberLiteral {
range: 4360..4361,
value: Int(
3,
),
},
),
op: Add,
right: NumberLiteral(
ExprNumberLiteral {
range: 4364..4366,
value: Complex {
real: 0.0,
imag: 1.0,
},
},
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4377..4380,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4377..4380,
},
),
},
),
],
},
MatchCase {
range: 4385..4413,
pattern: MatchSequence(
PatternMatchSequence {
range: 4390..4400,
patterns: [
MatchSequence(
PatternMatchSequence {
range: 4391..4396,
patterns: [
MatchValue(
PatternMatchValue {
range: 4392..4393,
value: NumberLiteral(
ExprNumberLiteral {
range: 4392..4393,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4394..4395,
value: NumberLiteral(
ExprNumberLiteral {
range: 4394..4395,
value: Int(
2,
),
},
),
},
),
],
},
),
MatchValue(
PatternMatchValue {
range: 4398..4399,
value: NumberLiteral(
ExprNumberLiteral {
range: 4398..4399,
value: Int(
3,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4410..4413,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4410..4413,
},
),
},
),
],
},
MatchCase {
range: 4418..4439,
pattern: MatchSequence(
PatternMatchSequence {
range: 4423..4426,
patterns: [
MatchValue(
PatternMatchValue {
range: 4424..4425,
value: NumberLiteral(
ExprNumberLiteral {
range: 4424..4425,
value: Int(
1,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4436..4439,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4436..4439,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 4460..4589,
subject: Name(
ExprName {
range: 4466..4467,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 4473..4494,
pattern: MatchSequence(
PatternMatchSequence {
range: 4478..4481,
patterns: [
MatchStar(
PatternMatchStar {
range: 4478..4480,
name: Some(
Identifier {
id: Name("a"),
range: 4479..4480,
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4491..4494,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4491..4494,
},
),
},
),
],
},
MatchCase {
range: 4499..4520,
pattern: MatchSequence(
PatternMatchSequence {
range: 4504..4507,
patterns: [
MatchStar(
PatternMatchStar {
range: 4504..4506,
name: None,
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4517..4520,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4517..4520,
},
),
},
),
],
},
MatchCase {
range: 4525..4556,
pattern: MatchSequence(
PatternMatchSequence {
range: 4530..4543,
patterns: [
MatchValue(
PatternMatchValue {
range: 4531..4532,
value: NumberLiteral(
ExprNumberLiteral {
range: 4531..4532,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4534..4535,
value: NumberLiteral(
ExprNumberLiteral {
range: 4534..4535,
value: Int(
2,
),
},
),
},
),
MatchStar(
PatternMatchStar {
range: 4537..4542,
name: Some(
Identifier {
id: Name("rest"),
range: 4538..4542,
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4553..4556,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4553..4556,
},
),
},
),
],
},
MatchCase {
range: 4561..4589,
pattern: MatchSequence(
PatternMatchSequence {
range: 4566..4576,
patterns: [
MatchStar(
PatternMatchStar {
range: 4567..4569,
name: None,
},
),
MatchValue(
PatternMatchValue {
range: 4571..4572,
value: NumberLiteral(
ExprNumberLiteral {
range: 4571..4572,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4574..4575,
value: NumberLiteral(
ExprNumberLiteral {
range: 4574..4575,
value: Int(
2,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4586..4589,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4586..4589,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 4611..4883,
subject: Name(
ExprName {
range: 4617..4618,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 4624..4649,
pattern: MatchClass(
PatternMatchClass {
range: 4629..4636,
cls: Name(
ExprName {
range: 4629..4634,
id: Name("Point"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4634..4636,
patterns: [],
keywords: [],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4646..4649,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4646..4649,
},
),
},
),
],
},
MatchCase {
range: 4654..4683,
pattern: MatchClass(
PatternMatchClass {
range: 4659..4670,
cls: Attribute(
ExprAttribute {
range: 4659..4668,
value: Attribute(
ExprAttribute {
range: 4659..4662,
value: Name(
ExprName {
range: 4659..4660,
id: Name("a"),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 4661..4662,
},
ctx: Load,
},
),
attr: Identifier {
id: Name("Point"),
range: 4663..4668,
},
ctx: Load,
},
),
arguments: PatternArguments {
range: 4668..4670,
patterns: [],
keywords: [],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4680..4683,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4680..4683,
},
),
},
),
],
},
MatchCase {
range: 4688..4718,
pattern: MatchClass(
PatternMatchClass {
range: 4693..4705,
cls: Name(
ExprName {
range: 4693..4700,
id: Name("Point2D"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4700..4705,
patterns: [],
keywords: [
PatternKeyword {
range: 4701..4704,
attr: Identifier {
id: Name("x"),
range: 4701..4702,
},
pattern: MatchValue(
PatternMatchValue {
range: 4703..4704,
value: NumberLiteral(
ExprNumberLiteral {
range: 4703..4704,
value: Int(
0,
),
},
),
},
),
},
],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4715..4718,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4715..4718,
},
),
},
),
],
},
MatchCase {
range: 4723..4759,
pattern: MatchClass(
PatternMatchClass {
range: 4728..4746,
cls: Name(
ExprName {
range: 4728..4735,
id: Name("Point2D"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4735..4746,
patterns: [],
keywords: [
PatternKeyword {
range: 4736..4739,
attr: Identifier {
id: Name("x"),
range: 4736..4737,
},
pattern: MatchValue(
PatternMatchValue {
range: 4738..4739,
value: NumberLiteral(
ExprNumberLiteral {
range: 4738..4739,
value: Int(
0,
),
},
),
},
),
},
PatternKeyword {
range: 4741..4744,
attr: Identifier {
id: Name("y"),
range: 4741..4742,
},
pattern: MatchValue(
PatternMatchValue {
range: 4743..4744,
value: NumberLiteral(
ExprNumberLiteral {
range: 4743..4744,
value: Int(
0,
),
},
),
},
),
},
],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4756..4759,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4756..4759,
},
),
},
),
],
},
MatchCase {
range: 4764..4795,
pattern: MatchClass(
PatternMatchClass {
range: 4769..4782,
cls: Name(
ExprName {
range: 4769..4776,
id: Name("Point2D"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4776..4782,
patterns: [
MatchValue(
PatternMatchValue {
range: 4777..4778,
value: NumberLiteral(
ExprNumberLiteral {
range: 4777..4778,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4780..4781,
value: NumberLiteral(
ExprNumberLiteral {
range: 4780..4781,
value: Int(
1,
),
},
),
},
),
],
keywords: [],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4792..4795,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4792..4795,
},
),
},
),
],
},
MatchCase {
range: 4800..4838,
pattern: MatchClass(
PatternMatchClass {
range: 4805..4825,
cls: Name(
ExprName {
range: 4805..4812,
id: Name("Point2D"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4812..4825,
patterns: [
MatchSequence(
PatternMatchSequence {
range: 4813..4819,
patterns: [
MatchValue(
PatternMatchValue {
range: 4814..4815,
value: NumberLiteral(
ExprNumberLiteral {
range: 4814..4815,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4817..4818,
value: NumberLiteral(
ExprNumberLiteral {
range: 4817..4818,
value: Int(
1,
),
},
),
},
),
],
},
),
],
keywords: [
PatternKeyword {
range: 4821..4824,
attr: Identifier {
id: Name("y"),
range: 4821..4822,
},
pattern: MatchValue(
PatternMatchValue {
range: 4823..4824,
value: NumberLiteral(
ExprNumberLiteral {
range: 4823..4824,
value: Int(
1,
),
},
),
},
),
},
],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4835..4838,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4835..4838,
},
),
},
),
],
},
MatchCase {
range: 4843..4883,
pattern: MatchClass(
PatternMatchClass {
range: 4848..4870,
cls: Name(
ExprName {
range: 4848..4855,
id: Name("Point2D"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4855..4870,
patterns: [],
keywords: [
PatternKeyword {
range: 4856..4864,
attr: Identifier {
id: Name("x"),
range: 4856..4857,
},
pattern: MatchSequence(
PatternMatchSequence {
range: 4858..4864,
patterns: [
MatchValue(
PatternMatchValue {
range: 4859..4860,
value: NumberLiteral(
ExprNumberLiteral {
range: 4859..4860,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4862..4863,
value: NumberLiteral(
ExprNumberLiteral {
range: 4862..4863,
value: Int(
1,
),
},
),
},
),
],
},
),
},
PatternKeyword {
range: 4866..4869,
attr: Identifier {
id: Name("y"),
range: 4866..4867,
},
pattern: MatchValue(
PatternMatchValue {
range: 4868..4869,
value: NumberLiteral(
ExprNumberLiteral {
range: 4868..4869,
value: Int(
1,
),
},
),
},
),
},
],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4880..4883,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4880..4883,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 4907..5001,
subject: Named(
ExprNamed {
range: 4913..4919,
target: Name(
ExprName {
range: 4913..4914,
id: Name("x"),
ctx: Store,
},
),
value: Name(
ExprName {
range: 4918..4919,
id: Name("b"),
ctx: Load,
},
),
},
),
cases: [
MatchCase {
range: 4925..4949,
pattern: MatchMapping(
PatternMatchMapping {
range: 4930..4936,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 4931..4932,
value: Int(
1,
),
},
),
],
patterns: [
MatchAs(
PatternMatchAs {
range: 4934..4935,
pattern: None,
name: None,
},
),
],
rest: None,
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4946..4949,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4946..4949,
},
),
},
),
],
},
MatchCase {
range: 4954..5001,
pattern: MatchMapping(
PatternMatchMapping {
range: 4959..4988,
keys: [
StringLiteral(
ExprStringLiteral {
range: 4960..4962,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 4960..4962,
value: "",
flags: StringLiteralFlags {
quote_style: Single,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
NoneLiteral(
ExprNoneLiteral {
range: 4967..4971,
},
),
],
patterns: [
MatchAs(
PatternMatchAs {
range: 4964..4965,
pattern: None,
name: Some(
Identifier {
id: Name("a"),
range: 4964..4965,
},
),
},
),
MatchSequence(
PatternMatchSequence {
range: 4973..4979,
patterns: [
MatchValue(
PatternMatchValue {
range: 4974..4975,
value: NumberLiteral(
ExprNumberLiteral {
range: 4974..4975,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4977..4978,
value: NumberLiteral(
ExprNumberLiteral {
range: 4977..4978,
value: Int(
2,
),
},
),
},
),
],
},
),
],
rest: Some(
Identifier {
id: Name("rest"),
range: 4983..4987,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4998..5001,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4998..5001,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 5019..5079,
subject: Name(
ExprName {
range: 5025..5026,
id: Name("y"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 5032..5053,
pattern: MatchAs(
PatternMatchAs {
range: 5037..5038,
pattern: None,
name: Some(
Identifier {
id: Name("a"),
range: 5037..5038,
},
),
},
),
guard: Some(
Named(
ExprNamed {
range: 5042..5048,
target: Name(
ExprName {
range: 5042..5043,
id: Name("b"),
ctx: Store,
},
),
value: Name(
ExprName {
range: 5047..5048,
id: Name("c"),
ctx: Load,
},
),
},
),
),
body: [
Expr(
StmtExpr {
range: 5050..5053,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 5050..5053,
},
),
},
),
],
},
MatchCase {
range: 5058..5079,
pattern: MatchAs(
PatternMatchAs {
range: 5063..5064,
pattern: None,
name: Some(
Identifier {
id: Name("e"),
range: 5063..5064,
},
),
},
),
guard: Some(
Compare(
ExprCompare {
range: 5069..5074,
left: NumberLiteral(
ExprNumberLiteral {
range: 5069..5070,
value: Int(
1,
),
},
),
ops: [
Lt,
],
comparators: [
NumberLiteral(
ExprNumberLiteral {
range: 5073..5074,
value: Int(
2,
),
},
),
],
},
),
),
body: [
Expr(
StmtExpr {
range: 5076..5079,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 5076..5079,
},
),
},
),
],
},
],
},
),
Expr(
StmtExpr {
range: 5108..5123,
value: Tuple(
ExprTuple {
range: 5108..5123,
elts: [
BinOp(
ExprBinOp {
range: 5108..5120,
left: BinOp(
ExprBinOp {
range: 5108..5116,
left: Name(
ExprName {
range: 5108..5113,
id: Name("match"),
ctx: Load,
},
),
op: Mult,
right: Name(
ExprName {
range: 5115..5116,
id: Name("a"),
ctx: Load,
},
),
},
),
op: Add,
right: Name(
ExprName {
range: 5119..5120,
id: Name("b"),
ctx: Load,
},
),
},
),
Name(
ExprName {
range: 5122..5123,
id: Name("c"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
},
),
Expr(
StmtExpr {
range: 5149..5166,
value: Tuple(
ExprTuple {
range: 5149..5166,
elts: [
BinOp(
ExprBinOp {
range: 5149..5163,
left: Name(
ExprName {
range: 5149..5154,
id: Name("match"),
ctx: Load,
},
),
op: Mult,
right: BinOp(
ExprBinOp {
range: 5157..5162,
left: Name(
ExprName {
range: 5157..5158,
id: Name("a"),
ctx: Load,
},
),
op: Add,
right: Name(
ExprName {
range: 5161..5162,
id: Name("b"),
ctx: Load,
},
),
},
),
},
),
Name(
ExprName {
range: 5165..5166,
id: Name("c"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
},
),
Expr(
StmtExpr {
range: 5192..5209,
value: Call(
ExprCall {
range: 5192..5209,
func: Name(
ExprName {
range: 5192..5197,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5198..5209,
args: [
Starred(
ExprStarred {
range: 5199..5205,
value: BinOp(
ExprBinOp {
range: 5200..5205,
left: Name(
ExprName {
range: 5200..5201,
id: Name("a"),
ctx: Load,
},
),
op: Add,
right: Name(
ExprName {
range: 5204..5205,
id: Name("b"),
ctx: Load,
},
),
},
),
ctx: Load,
},
),
Name(
ExprName {
range: 5207..5208,
id: Name("c"),
ctx: Load,
},
),
],
keywords: [],
},
},
),
},
),
Expr(
StmtExpr {
range: 5236..5252,
value: BinOp(
ExprBinOp {
range: 5236..5252,
left: BinOp(
ExprBinOp {
range: 5236..5248,
left: Name(
ExprName {
range: 5236..5241,
id: Name("match"),
ctx: Load,
},
),
op: Sub,
right: BinOp(
ExprBinOp {
range: 5243..5248,
left: Name(
ExprName {
range: 5243..5244,
id: Name("a"),
ctx: Load,
},
),
op: Mult,
right: Name(
ExprName {
range: 5247..5248,
id: Name("b"),
ctx: Load,
},
),
},
),
},
),
op: Add,
right: Name(
ExprName {
range: 5251..5252,
id: Name("c"),
ctx: Load,
},
),
},
),
},
),
Expr(
StmtExpr {
range: 5279..5297,
value: BinOp(
ExprBinOp {
range: 5279..5297,
left: BinOp(
ExprBinOp {
range: 5279..5293,
left: Name(
ExprName {
range: 5279..5284,
id: Name("match"),
ctx: Load,
},
),
op: Sub,
right: BinOp(
ExprBinOp {
range: 5287..5292,
left: Name(
ExprName {
range: 5287..5288,
id: Name("a"),
ctx: Load,
},
),
op: Mult,
right: Name(
ExprName {
range: 5291..5292,
id: Name("b"),
ctx: Load,
},
),
},
),
},
),
op: Add,
right: Name(
ExprName {
range: 5296..5297,
id: Name("c"),
ctx: Load,
},
),
},
),
},
),
Expr(
StmtExpr {
range: 5324..5342,
value: BinOp(
ExprBinOp {
range: 5324..5342,
left: BinOp(
ExprBinOp {
range: 5324..5338,
left: Call(
ExprCall {
range: 5324..5334,
func: Name(
ExprName {
range: 5324..5329,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5330..5334,
args: [
UnaryOp(
ExprUnaryOp {
range: 5331..5333,
op: USub,
operand: Name(
ExprName {
range: 5332..5333,
id: Name("a"),
ctx: Load,
},
),
},
),
],
keywords: [],
},
},
),
op: Mult,
right: Name(
ExprName {
range: 5337..5338,
id: Name("b"),
ctx: Load,
},
),
},
),
op: Add,
right: Name(
ExprName {
range: 5341..5342,
id: Name("c"),
ctx: Load,
},
),
},
),
},
),
Expr(
StmtExpr {
range: 5370..5380,
value: Attribute(
ExprAttribute {
range: 5370..5380,
value: Call(
ExprCall {
range: 5370..5378,
func: Name(
ExprName {
range: 5370..5375,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5376..5378,
args: [],
keywords: [],
},
},
),
attr: Identifier {
id: Name("a"),
range: 5379..5380,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5397..5409,
value: Attribute(
ExprAttribute {
range: 5397..5409,
value: Call(
ExprCall {
range: 5397..5407,
func: Name(
ExprName {
range: 5397..5402,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5403..5407,
args: [
Tuple(
ExprTuple {
range: 5404..5406,
elts: [],
ctx: Load,
parenthesized: true,
},
),
],
keywords: [],
},
},
),
attr: Identifier {
id: Name("a"),
range: 5408..5409,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5428..5441,
value: Attribute(
ExprAttribute {
range: 5428..5441,
value: Call(
ExprCall {
range: 5428..5439,
func: Name(
ExprName {
range: 5428..5433,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5434..5439,
args: [
Tuple(
ExprTuple {
range: 5435..5437,
elts: [],
ctx: Load,
parenthesized: true,
},
),
],
keywords: [],
},
},
),
attr: Identifier {
id: Name("a"),
range: 5440..5441,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5460..5471,
value: Attribute(
ExprAttribute {
range: 5460..5471,
value: Subscript(
ExprSubscript {
range: 5460..5469,
value: Name(
ExprName {
range: 5460..5465,
id: Name("match"),
ctx: Load,
},
),
slice: Name(
ExprName {
range: 5467..5468,
id: Name("a"),
ctx: Load,
},
),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 5470..5471,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5489..5501,
value: Attribute(
ExprAttribute {
range: 5489..5501,
value: Subscript(
ExprSubscript {
range: 5489..5499,
value: Name(
ExprName {
range: 5489..5494,
id: Name("match"),
ctx: Load,
},
),
slice: Tuple(
ExprTuple {
range: 5496..5498,
elts: [
Name(
ExprName {
range: 5496..5497,
id: Name("a"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 5500..5501,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5542..5556,
value: Attribute(
ExprAttribute {
range: 5542..5556,
value: Subscript(
ExprSubscript {
range: 5542..5554,
value: Name(
ExprName {
range: 5542..5547,
id: Name("match"),
ctx: Load,
},
),
slice: Tuple(
ExprTuple {
range: 5549..5553,
elts: [
Name(
ExprName {
range: 5550..5551,
id: Name("a"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: true,
},
),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 5555..5556,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5577..5594,
value: Subscript(
ExprSubscript {
range: 5577..5594,
value: Call(
ExprCall {
range: 5577..5584,
func: Name(
ExprName {
range: 5577..5582,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5582..5584,
args: [],
keywords: [],
},
},
),
slice: Slice(
ExprSlice {
range: 5585..5593,
lower: Some(
Name(
ExprName {
range: 5585..5586,
id: Name("a"),
ctx: Load,
},
),
),
upper: Some(
Name(
ExprName {
range: 5592..5593,
id: Name("b"),
ctx: Load,
},
),
),
step: None,
},
),
ctx: Load,
},
),
},
),
If(
StmtIf {
range: 5614..5633,
test: Named(
ExprNamed {
range: 5617..5627,
target: Name(
ExprName {
range: 5617..5622,
id: Name("match"),
ctx: Store,
},
),
value: NumberLiteral(
ExprNumberLiteral {
range: 5626..5627,
value: Int(
1,
),
},
),
},
),
body: [
Pass(
StmtPass {
range: 5629..5633,
},
),
],
elif_else_clauses: [],
},
),
Match(
StmtMatch {
range: 5634..5688,
subject: Name(
ExprName {
range: 5640..5645,
id: Name("match"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 5651..5663,
pattern: MatchValue(
PatternMatchValue {
range: 5656..5657,
value: NumberLiteral(
ExprNumberLiteral {
range: 5656..5657,
value: Int(
1,
),
},
),
},
),
guard: None,
body: [
Pass(
StmtPass {
range: 5659..5663,
},
),
],
},
MatchCase {
range: 5668..5688,
pattern: MatchValue(
PatternMatchValue {
range: 5673..5674,
value: NumberLiteral(
ExprNumberLiteral {
range: 5673..5674,
value: Int(
2,
),
},
),
},
),
guard: None,
body: [
Pass(
StmtPass {
range: 5684..5688,
},
),
],
},
],
},
),
Assign(
StmtAssign {
range: 5689..5725,
targets: [
Name(
ExprName {
range: 5689..5694,
id: Name("match"),
ctx: Store,
},
),
],
value: Lambda(
ExprLambda {
range: 5697..5725,
parameters: Some(
Parameters {
range: 5704..5709,
posonlyargs: [],
args: [
ParameterWithDefault {
range: 5704..5709,
parameter: Parameter {
range: 5704..5709,
name: Identifier {
id: Name("query"),
range: 5704..5709,
},
annotation: None,
},
default: None,
},
],
vararg: None,
kwonlyargs: [],
kwarg: None,
},
),
body: Compare(
ExprCompare {
range: 5711..5725,
left: Name(
ExprName {
range: 5711..5716,
id: Name("query"),
ctx: Load,
},
),
ops: [
Eq,
],
comparators: [
Name(
ExprName {
range: 5720..5725,
id: Name("event"),
ctx: Load,
},
),
],
},
),
},
),
},
),
Expr(
StmtExpr {
range: 5726..5742,
value: Call(
ExprCall {
range: 5726..5742,
func: Name(
ExprName {
range: 5726..5731,
id: Name("print"),
ctx: Load,
},
),
arguments: Arguments {
range: 5731..5742,
args: [
Call(
ExprCall {
range: 5732..5741,
func: Name(
ExprName {
range: 5732..5737,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5737..5741,
args: [
NumberLiteral(
ExprNumberLiteral {
range: 5738..5740,
value: Int(
12,
),
},
),
],
keywords: [],
},
},
),
],
keywords: [],
},
},
),
},
),
],
},
)
```
Reference in a new issue View git blame Copy permalink