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
Brent Westbrook 5697d21fca
[syntax-errors] Irrefutable case pattern before final case (#16905) 
Summary
--

Detects irrefutable `match` cases before the final case using a modified
version
of the existing `Pattern::is_irrefutable` method from the AST crate. The
modified method helps to retrieve a more precise diagnostic range to
match what
Python 3.13 shows in the REPL.

Test Plan
--

New inline tests, as well as some updates to existing tests that had
irrefutable
patterns before the last block.
2025-03-26 12:27:16 -04:00

7758 lines
392 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..5770,
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..3978,
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,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 3979..4016,
subject: Name(
ExprName {
range: 3985..3986,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 3992..4016,
pattern: MatchAs(
PatternMatchAs {
range: 3997..4003,
pattern: Some(
MatchAs(
PatternMatchAs {
range: 3997..3998,
pattern: None,
name: Some(
Identifier {
id: Name("a"),
range: 3997..3998,
},
),
},
),
),
name: Some(
Identifier {
id: Name("b"),
range: 4002..4003,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4013..4016,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4013..4016,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 4017..4157,
subject: Name(
ExprName {
range: 4023..4024,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 4030..4060,
pattern: MatchAs(
PatternMatchAs {
range: 4035..4047,
pattern: Some(
MatchOr(
PatternMatchOr {
range: 4035..4040,
patterns: [
MatchValue(
PatternMatchValue {
range: 4035..4036,
value: NumberLiteral(
ExprNumberLiteral {
range: 4035..4036,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4039..4040,
value: NumberLiteral(
ExprNumberLiteral {
range: 4039..4040,
value: Int(
2,
),
},
),
},
),
],
},
),
),
name: Some(
Identifier {
id: Name("two"),
range: 4044..4047,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4057..4060,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4057..4060,
},
),
},
),
],
},
MatchCase {
range: 4065..4096,
pattern: MatchAs(
PatternMatchAs {
range: 4070..4083,
pattern: Some(
MatchValue(
PatternMatchValue {
range: 4070..4076,
value: BinOp(
ExprBinOp {
range: 4070..4076,
left: NumberLiteral(
ExprNumberLiteral {
range: 4070..4071,
value: Int(
1,
),
},
),
op: Add,
right: NumberLiteral(
ExprNumberLiteral {
range: 4074..4076,
value: Complex {
real: 0.0,
imag: 3.0,
},
},
),
},
),
},
),
),
name: Some(
Identifier {
id: Name("sum"),
range: 4080..4083,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4093..4096,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4093..4096,
},
),
},
),
],
},
MatchCase {
range: 4101..4128,
pattern: MatchAs(
PatternMatchAs {
range: 4106..4115,
pattern: Some(
MatchValue(
PatternMatchValue {
range: 4106..4109,
value: Attribute(
ExprAttribute {
range: 4106..4109,
value: Name(
ExprName {
range: 4106..4107,
id: Name("a"),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 4108..4109,
},
ctx: Load,
},
),
},
),
),
name: Some(
Identifier {
id: Name("ab"),
range: 4113..4115,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4125..4128,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4125..4128,
},
),
},
),
],
},
MatchCase {
range: 4133..4157,
pattern: MatchAs(
PatternMatchAs {
range: 4138..4144,
pattern: Some(
MatchAs(
PatternMatchAs {
range: 4138..4139,
pattern: None,
name: None,
},
),
),
name: Some(
Identifier {
id: Name("x"),
range: 4143..4144,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4154..4157,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4154..4157,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 4158..4190,
subject: Name(
ExprName {
range: 4164..4165,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 4171..4190,
pattern: MatchAs(
PatternMatchAs {
range: 4176..4177,
pattern: None,
name: None,
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4187..4190,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4187..4190,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 4215..4466,
subject: Name(
ExprName {
range: 4221..4222,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 4228..4253,
pattern: MatchSequence(
PatternMatchSequence {
range: 4233..4240,
patterns: [
MatchValue(
PatternMatchValue {
range: 4233..4234,
value: NumberLiteral(
ExprNumberLiteral {
range: 4233..4234,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4236..4237,
value: NumberLiteral(
ExprNumberLiteral {
range: 4236..4237,
value: Int(
2,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4239..4240,
value: NumberLiteral(
ExprNumberLiteral {
range: 4239..4240,
value: Int(
3,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4250..4253,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4250..4253,
},
),
},
),
],
},
MatchCase {
range: 4258..4286,
pattern: MatchSequence(
PatternMatchSequence {
range: 4263..4273,
patterns: [
MatchValue(
PatternMatchValue {
range: 4264..4265,
value: NumberLiteral(
ExprNumberLiteral {
range: 4264..4265,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4267..4268,
value: NumberLiteral(
ExprNumberLiteral {
range: 4267..4268,
value: Int(
2,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4270..4271,
value: NumberLiteral(
ExprNumberLiteral {
range: 4270..4271,
value: Int(
3,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4283..4286,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4283..4286,
},
),
},
),
],
},
MatchCase {
range: 4291..4331,
pattern: MatchSequence(
PatternMatchSequence {
range: 4296..4318,
patterns: [
MatchValue(
PatternMatchValue {
range: 4297..4303,
value: BinOp(
ExprBinOp {
range: 4297..4303,
left: NumberLiteral(
ExprNumberLiteral {
range: 4297..4298,
value: Int(
1,
),
},
),
op: Add,
right: NumberLiteral(
ExprNumberLiteral {
range: 4301..4303,
value: Complex {
real: 0.0,
imag: 2.0,
},
},
),
},
),
},
),
MatchAs(
PatternMatchAs {
range: 4305..4306,
pattern: None,
name: Some(
Identifier {
id: Name("a"),
range: 4305..4306,
},
),
},
),
MatchSingleton(
PatternMatchSingleton {
range: 4308..4312,
value: None,
},
),
MatchValue(
PatternMatchValue {
range: 4314..4317,
value: Attribute(
ExprAttribute {
range: 4314..4317,
value: Name(
ExprName {
range: 4314..4315,
id: Name("a"),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 4316..4317,
},
ctx: Load,
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4328..4331,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4328..4331,
},
),
},
),
],
},
MatchCase {
range: 4336..4370,
pattern: MatchAs(
PatternMatchAs {
range: 4341..4357,
pattern: Some(
MatchSequence(
PatternMatchSequence {
range: 4341..4352,
patterns: [
MatchAs(
PatternMatchAs {
range: 4342..4348,
pattern: Some(
MatchValue(
PatternMatchValue {
range: 4342..4343,
value: NumberLiteral(
ExprNumberLiteral {
range: 4342..4343,
value: Int(
1,
),
},
),
},
),
),
name: Some(
Identifier {
id: Name("X"),
range: 4347..4348,
},
),
},
),
MatchAs(
PatternMatchAs {
range: 4350..4351,
pattern: None,
name: Some(
Identifier {
id: Name("b"),
range: 4350..4351,
},
),
},
),
],
},
),
),
name: Some(
Identifier {
id: Name("S"),
range: 4356..4357,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4367..4370,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4367..4370,
},
),
},
),
],
},
MatchCase {
range: 4375..4407,
pattern: MatchSequence(
PatternMatchSequence {
range: 4380..4394,
patterns: [
MatchValue(
PatternMatchValue {
range: 4381..4382,
value: NumberLiteral(
ExprNumberLiteral {
range: 4381..4382,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4384..4385,
value: NumberLiteral(
ExprNumberLiteral {
range: 4384..4385,
value: Int(
2,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4387..4393,
value: BinOp(
ExprBinOp {
range: 4387..4393,
left: NumberLiteral(
ExprNumberLiteral {
range: 4387..4388,
value: Int(
3,
),
},
),
op: Add,
right: NumberLiteral(
ExprNumberLiteral {
range: 4391..4393,
value: Complex {
real: 0.0,
imag: 1.0,
},
},
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4404..4407,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4404..4407,
},
),
},
),
],
},
MatchCase {
range: 4412..4440,
pattern: MatchSequence(
PatternMatchSequence {
range: 4417..4427,
patterns: [
MatchSequence(
PatternMatchSequence {
range: 4418..4423,
patterns: [
MatchValue(
PatternMatchValue {
range: 4419..4420,
value: NumberLiteral(
ExprNumberLiteral {
range: 4419..4420,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4421..4422,
value: NumberLiteral(
ExprNumberLiteral {
range: 4421..4422,
value: Int(
2,
),
},
),
},
),
],
},
),
MatchValue(
PatternMatchValue {
range: 4425..4426,
value: NumberLiteral(
ExprNumberLiteral {
range: 4425..4426,
value: Int(
3,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4437..4440,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4437..4440,
},
),
},
),
],
},
MatchCase {
range: 4445..4466,
pattern: MatchSequence(
PatternMatchSequence {
range: 4450..4453,
patterns: [
MatchValue(
PatternMatchValue {
range: 4451..4452,
value: NumberLiteral(
ExprNumberLiteral {
range: 4451..4452,
value: Int(
1,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4463..4466,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4463..4466,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 4487..4616,
subject: Name(
ExprName {
range: 4493..4494,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 4500..4521,
pattern: MatchSequence(
PatternMatchSequence {
range: 4505..4508,
patterns: [
MatchStar(
PatternMatchStar {
range: 4505..4507,
name: Some(
Identifier {
id: Name("a"),
range: 4506..4507,
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4518..4521,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4518..4521,
},
),
},
),
],
},
MatchCase {
range: 4526..4547,
pattern: MatchSequence(
PatternMatchSequence {
range: 4531..4534,
patterns: [
MatchStar(
PatternMatchStar {
range: 4531..4533,
name: None,
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4544..4547,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4544..4547,
},
),
},
),
],
},
MatchCase {
range: 4552..4583,
pattern: MatchSequence(
PatternMatchSequence {
range: 4557..4570,
patterns: [
MatchValue(
PatternMatchValue {
range: 4558..4559,
value: NumberLiteral(
ExprNumberLiteral {
range: 4558..4559,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4561..4562,
value: NumberLiteral(
ExprNumberLiteral {
range: 4561..4562,
value: Int(
2,
),
},
),
},
),
MatchStar(
PatternMatchStar {
range: 4564..4569,
name: Some(
Identifier {
id: Name("rest"),
range: 4565..4569,
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4580..4583,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4580..4583,
},
),
},
),
],
},
MatchCase {
range: 4588..4616,
pattern: MatchSequence(
PatternMatchSequence {
range: 4593..4603,
patterns: [
MatchStar(
PatternMatchStar {
range: 4594..4596,
name: None,
},
),
MatchValue(
PatternMatchValue {
range: 4598..4599,
value: NumberLiteral(
ExprNumberLiteral {
range: 4598..4599,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4601..4602,
value: NumberLiteral(
ExprNumberLiteral {
range: 4601..4602,
value: Int(
2,
),
},
),
},
),
],
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4613..4616,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4613..4616,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 4638..4910,
subject: Name(
ExprName {
range: 4644..4645,
id: Name("x"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 4651..4676,
pattern: MatchClass(
PatternMatchClass {
range: 4656..4663,
cls: Name(
ExprName {
range: 4656..4661,
id: Name("Point"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4661..4663,
patterns: [],
keywords: [],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4673..4676,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4673..4676,
},
),
},
),
],
},
MatchCase {
range: 4681..4710,
pattern: MatchClass(
PatternMatchClass {
range: 4686..4697,
cls: Attribute(
ExprAttribute {
range: 4686..4695,
value: Attribute(
ExprAttribute {
range: 4686..4689,
value: Name(
ExprName {
range: 4686..4687,
id: Name("a"),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 4688..4689,
},
ctx: Load,
},
),
attr: Identifier {
id: Name("Point"),
range: 4690..4695,
},
ctx: Load,
},
),
arguments: PatternArguments {
range: 4695..4697,
patterns: [],
keywords: [],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4707..4710,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4707..4710,
},
),
},
),
],
},
MatchCase {
range: 4715..4745,
pattern: MatchClass(
PatternMatchClass {
range: 4720..4732,
cls: Name(
ExprName {
range: 4720..4727,
id: Name("Point2D"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4727..4732,
patterns: [],
keywords: [
PatternKeyword {
range: 4728..4731,
attr: Identifier {
id: Name("x"),
range: 4728..4729,
},
pattern: MatchValue(
PatternMatchValue {
range: 4730..4731,
value: NumberLiteral(
ExprNumberLiteral {
range: 4730..4731,
value: Int(
0,
),
},
),
},
),
},
],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4742..4745,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4742..4745,
},
),
},
),
],
},
MatchCase {
range: 4750..4786,
pattern: MatchClass(
PatternMatchClass {
range: 4755..4773,
cls: Name(
ExprName {
range: 4755..4762,
id: Name("Point2D"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4762..4773,
patterns: [],
keywords: [
PatternKeyword {
range: 4763..4766,
attr: Identifier {
id: Name("x"),
range: 4763..4764,
},
pattern: MatchValue(
PatternMatchValue {
range: 4765..4766,
value: NumberLiteral(
ExprNumberLiteral {
range: 4765..4766,
value: Int(
0,
),
},
),
},
),
},
PatternKeyword {
range: 4768..4771,
attr: Identifier {
id: Name("y"),
range: 4768..4769,
},
pattern: MatchValue(
PatternMatchValue {
range: 4770..4771,
value: NumberLiteral(
ExprNumberLiteral {
range: 4770..4771,
value: Int(
0,
),
},
),
},
),
},
],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4783..4786,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4783..4786,
},
),
},
),
],
},
MatchCase {
range: 4791..4822,
pattern: MatchClass(
PatternMatchClass {
range: 4796..4809,
cls: Name(
ExprName {
range: 4796..4803,
id: Name("Point2D"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4803..4809,
patterns: [
MatchValue(
PatternMatchValue {
range: 4804..4805,
value: NumberLiteral(
ExprNumberLiteral {
range: 4804..4805,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4807..4808,
value: NumberLiteral(
ExprNumberLiteral {
range: 4807..4808,
value: Int(
1,
),
},
),
},
),
],
keywords: [],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4819..4822,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4819..4822,
},
),
},
),
],
},
MatchCase {
range: 4827..4865,
pattern: MatchClass(
PatternMatchClass {
range: 4832..4852,
cls: Name(
ExprName {
range: 4832..4839,
id: Name("Point2D"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4839..4852,
patterns: [
MatchSequence(
PatternMatchSequence {
range: 4840..4846,
patterns: [
MatchValue(
PatternMatchValue {
range: 4841..4842,
value: NumberLiteral(
ExprNumberLiteral {
range: 4841..4842,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4844..4845,
value: NumberLiteral(
ExprNumberLiteral {
range: 4844..4845,
value: Int(
1,
),
},
),
},
),
],
},
),
],
keywords: [
PatternKeyword {
range: 4848..4851,
attr: Identifier {
id: Name("y"),
range: 4848..4849,
},
pattern: MatchValue(
PatternMatchValue {
range: 4850..4851,
value: NumberLiteral(
ExprNumberLiteral {
range: 4850..4851,
value: Int(
1,
),
},
),
},
),
},
],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4862..4865,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4862..4865,
},
),
},
),
],
},
MatchCase {
range: 4870..4910,
pattern: MatchClass(
PatternMatchClass {
range: 4875..4897,
cls: Name(
ExprName {
range: 4875..4882,
id: Name("Point2D"),
ctx: Load,
},
),
arguments: PatternArguments {
range: 4882..4897,
patterns: [],
keywords: [
PatternKeyword {
range: 4883..4891,
attr: Identifier {
id: Name("x"),
range: 4883..4884,
},
pattern: MatchSequence(
PatternMatchSequence {
range: 4885..4891,
patterns: [
MatchValue(
PatternMatchValue {
range: 4886..4887,
value: NumberLiteral(
ExprNumberLiteral {
range: 4886..4887,
value: Int(
0,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 4889..4890,
value: NumberLiteral(
ExprNumberLiteral {
range: 4889..4890,
value: Int(
1,
),
},
),
},
),
],
},
),
},
PatternKeyword {
range: 4893..4896,
attr: Identifier {
id: Name("y"),
range: 4893..4894,
},
pattern: MatchValue(
PatternMatchValue {
range: 4895..4896,
value: NumberLiteral(
ExprNumberLiteral {
range: 4895..4896,
value: Int(
1,
),
},
),
},
),
},
],
},
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4907..4910,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4907..4910,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 4934..5028,
subject: Named(
ExprNamed {
range: 4940..4946,
target: Name(
ExprName {
range: 4940..4941,
id: Name("x"),
ctx: Store,
},
),
value: Name(
ExprName {
range: 4945..4946,
id: Name("b"),
ctx: Load,
},
),
},
),
cases: [
MatchCase {
range: 4952..4976,
pattern: MatchMapping(
PatternMatchMapping {
range: 4957..4963,
keys: [
NumberLiteral(
ExprNumberLiteral {
range: 4958..4959,
value: Int(
1,
),
},
),
],
patterns: [
MatchAs(
PatternMatchAs {
range: 4961..4962,
pattern: None,
name: None,
},
),
],
rest: None,
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 4973..4976,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 4973..4976,
},
),
},
),
],
},
MatchCase {
range: 4981..5028,
pattern: MatchMapping(
PatternMatchMapping {
range: 4986..5015,
keys: [
StringLiteral(
ExprStringLiteral {
range: 4987..4989,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 4987..4989,
value: "",
flags: StringLiteralFlags {
quote_style: Single,
prefix: Empty,
triple_quoted: false,
},
},
),
},
},
),
NoneLiteral(
ExprNoneLiteral {
range: 4994..4998,
},
),
],
patterns: [
MatchAs(
PatternMatchAs {
range: 4991..4992,
pattern: None,
name: Some(
Identifier {
id: Name("a"),
range: 4991..4992,
},
),
},
),
MatchSequence(
PatternMatchSequence {
range: 5000..5006,
patterns: [
MatchValue(
PatternMatchValue {
range: 5001..5002,
value: NumberLiteral(
ExprNumberLiteral {
range: 5001..5002,
value: Int(
1,
),
},
),
},
),
MatchValue(
PatternMatchValue {
range: 5004..5005,
value: NumberLiteral(
ExprNumberLiteral {
range: 5004..5005,
value: Int(
2,
),
},
),
},
),
],
},
),
],
rest: Some(
Identifier {
id: Name("rest"),
range: 5010..5014,
},
),
},
),
guard: None,
body: [
Expr(
StmtExpr {
range: 5025..5028,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 5025..5028,
},
),
},
),
],
},
],
},
),
Match(
StmtMatch {
range: 5046..5106,
subject: Name(
ExprName {
range: 5052..5053,
id: Name("y"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 5059..5080,
pattern: MatchAs(
PatternMatchAs {
range: 5064..5065,
pattern: None,
name: Some(
Identifier {
id: Name("a"),
range: 5064..5065,
},
),
},
),
guard: Some(
Named(
ExprNamed {
range: 5069..5075,
target: Name(
ExprName {
range: 5069..5070,
id: Name("b"),
ctx: Store,
},
),
value: Name(
ExprName {
range: 5074..5075,
id: Name("c"),
ctx: Load,
},
),
},
),
),
body: [
Expr(
StmtExpr {
range: 5077..5080,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 5077..5080,
},
),
},
),
],
},
MatchCase {
range: 5085..5106,
pattern: MatchAs(
PatternMatchAs {
range: 5090..5091,
pattern: None,
name: Some(
Identifier {
id: Name("e"),
range: 5090..5091,
},
),
},
),
guard: Some(
Compare(
ExprCompare {
range: 5096..5101,
left: NumberLiteral(
ExprNumberLiteral {
range: 5096..5097,
value: Int(
1,
),
},
),
ops: [
Lt,
],
comparators: [
NumberLiteral(
ExprNumberLiteral {
range: 5100..5101,
value: Int(
2,
),
},
),
],
},
),
),
body: [
Expr(
StmtExpr {
range: 5103..5106,
value: EllipsisLiteral(
ExprEllipsisLiteral {
range: 5103..5106,
},
),
},
),
],
},
],
},
),
Expr(
StmtExpr {
range: 5135..5150,
value: Tuple(
ExprTuple {
range: 5135..5150,
elts: [
BinOp(
ExprBinOp {
range: 5135..5147,
left: BinOp(
ExprBinOp {
range: 5135..5143,
left: Name(
ExprName {
range: 5135..5140,
id: Name("match"),
ctx: Load,
},
),
op: Mult,
right: Name(
ExprName {
range: 5142..5143,
id: Name("a"),
ctx: Load,
},
),
},
),
op: Add,
right: Name(
ExprName {
range: 5146..5147,
id: Name("b"),
ctx: Load,
},
),
},
),
Name(
ExprName {
range: 5149..5150,
id: Name("c"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
},
),
Expr(
StmtExpr {
range: 5176..5193,
value: Tuple(
ExprTuple {
range: 5176..5193,
elts: [
BinOp(
ExprBinOp {
range: 5176..5190,
left: Name(
ExprName {
range: 5176..5181,
id: Name("match"),
ctx: Load,
},
),
op: Mult,
right: BinOp(
ExprBinOp {
range: 5184..5189,
left: Name(
ExprName {
range: 5184..5185,
id: Name("a"),
ctx: Load,
},
),
op: Add,
right: Name(
ExprName {
range: 5188..5189,
id: Name("b"),
ctx: Load,
},
),
},
),
},
),
Name(
ExprName {
range: 5192..5193,
id: Name("c"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
},
),
Expr(
StmtExpr {
range: 5219..5236,
value: Call(
ExprCall {
range: 5219..5236,
func: Name(
ExprName {
range: 5219..5224,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5225..5236,
args: [
Starred(
ExprStarred {
range: 5226..5232,
value: BinOp(
ExprBinOp {
range: 5227..5232,
left: Name(
ExprName {
range: 5227..5228,
id: Name("a"),
ctx: Load,
},
),
op: Add,
right: Name(
ExprName {
range: 5231..5232,
id: Name("b"),
ctx: Load,
},
),
},
),
ctx: Load,
},
),
Name(
ExprName {
range: 5234..5235,
id: Name("c"),
ctx: Load,
},
),
],
keywords: [],
},
},
),
},
),
Expr(
StmtExpr {
range: 5263..5279,
value: BinOp(
ExprBinOp {
range: 5263..5279,
left: BinOp(
ExprBinOp {
range: 5263..5275,
left: Name(
ExprName {
range: 5263..5268,
id: Name("match"),
ctx: Load,
},
),
op: Sub,
right: BinOp(
ExprBinOp {
range: 5270..5275,
left: Name(
ExprName {
range: 5270..5271,
id: Name("a"),
ctx: Load,
},
),
op: Mult,
right: Name(
ExprName {
range: 5274..5275,
id: Name("b"),
ctx: Load,
},
),
},
),
},
),
op: Add,
right: Name(
ExprName {
range: 5278..5279,
id: Name("c"),
ctx: Load,
},
),
},
),
},
),
Expr(
StmtExpr {
range: 5306..5324,
value: BinOp(
ExprBinOp {
range: 5306..5324,
left: BinOp(
ExprBinOp {
range: 5306..5320,
left: Name(
ExprName {
range: 5306..5311,
id: Name("match"),
ctx: Load,
},
),
op: Sub,
right: BinOp(
ExprBinOp {
range: 5314..5319,
left: Name(
ExprName {
range: 5314..5315,
id: Name("a"),
ctx: Load,
},
),
op: Mult,
right: Name(
ExprName {
range: 5318..5319,
id: Name("b"),
ctx: Load,
},
),
},
),
},
),
op: Add,
right: Name(
ExprName {
range: 5323..5324,
id: Name("c"),
ctx: Load,
},
),
},
),
},
),
Expr(
StmtExpr {
range: 5351..5369,
value: BinOp(
ExprBinOp {
range: 5351..5369,
left: BinOp(
ExprBinOp {
range: 5351..5365,
left: Call(
ExprCall {
range: 5351..5361,
func: Name(
ExprName {
range: 5351..5356,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5357..5361,
args: [
UnaryOp(
ExprUnaryOp {
range: 5358..5360,
op: USub,
operand: Name(
ExprName {
range: 5359..5360,
id: Name("a"),
ctx: Load,
},
),
},
),
],
keywords: [],
},
},
),
op: Mult,
right: Name(
ExprName {
range: 5364..5365,
id: Name("b"),
ctx: Load,
},
),
},
),
op: Add,
right: Name(
ExprName {
range: 5368..5369,
id: Name("c"),
ctx: Load,
},
),
},
),
},
),
Expr(
StmtExpr {
range: 5397..5407,
value: Attribute(
ExprAttribute {
range: 5397..5407,
value: Call(
ExprCall {
range: 5397..5405,
func: Name(
ExprName {
range: 5397..5402,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5403..5405,
args: [],
keywords: [],
},
},
),
attr: Identifier {
id: Name("a"),
range: 5406..5407,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5424..5436,
value: Attribute(
ExprAttribute {
range: 5424..5436,
value: Call(
ExprCall {
range: 5424..5434,
func: Name(
ExprName {
range: 5424..5429,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5430..5434,
args: [
Tuple(
ExprTuple {
range: 5431..5433,
elts: [],
ctx: Load,
parenthesized: true,
},
),
],
keywords: [],
},
},
),
attr: Identifier {
id: Name("a"),
range: 5435..5436,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5455..5468,
value: Attribute(
ExprAttribute {
range: 5455..5468,
value: Call(
ExprCall {
range: 5455..5466,
func: Name(
ExprName {
range: 5455..5460,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5461..5466,
args: [
Tuple(
ExprTuple {
range: 5462..5464,
elts: [],
ctx: Load,
parenthesized: true,
},
),
],
keywords: [],
},
},
),
attr: Identifier {
id: Name("a"),
range: 5467..5468,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5487..5498,
value: Attribute(
ExprAttribute {
range: 5487..5498,
value: Subscript(
ExprSubscript {
range: 5487..5496,
value: Name(
ExprName {
range: 5487..5492,
id: Name("match"),
ctx: Load,
},
),
slice: Name(
ExprName {
range: 5494..5495,
id: Name("a"),
ctx: Load,
},
),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 5497..5498,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5516..5528,
value: Attribute(
ExprAttribute {
range: 5516..5528,
value: Subscript(
ExprSubscript {
range: 5516..5526,
value: Name(
ExprName {
range: 5516..5521,
id: Name("match"),
ctx: Load,
},
),
slice: Tuple(
ExprTuple {
range: 5523..5525,
elts: [
Name(
ExprName {
range: 5523..5524,
id: Name("a"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: false,
},
),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 5527..5528,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5569..5583,
value: Attribute(
ExprAttribute {
range: 5569..5583,
value: Subscript(
ExprSubscript {
range: 5569..5581,
value: Name(
ExprName {
range: 5569..5574,
id: Name("match"),
ctx: Load,
},
),
slice: Tuple(
ExprTuple {
range: 5576..5580,
elts: [
Name(
ExprName {
range: 5577..5578,
id: Name("a"),
ctx: Load,
},
),
],
ctx: Load,
parenthesized: true,
},
),
ctx: Load,
},
),
attr: Identifier {
id: Name("b"),
range: 5582..5583,
},
ctx: Load,
},
),
},
),
Expr(
StmtExpr {
range: 5604..5621,
value: Subscript(
ExprSubscript {
range: 5604..5621,
value: Call(
ExprCall {
range: 5604..5611,
func: Name(
ExprName {
range: 5604..5609,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5609..5611,
args: [],
keywords: [],
},
},
),
slice: Slice(
ExprSlice {
range: 5612..5620,
lower: Some(
Name(
ExprName {
range: 5612..5613,
id: Name("a"),
ctx: Load,
},
),
),
upper: Some(
Name(
ExprName {
range: 5619..5620,
id: Name("b"),
ctx: Load,
},
),
),
step: None,
},
),
ctx: Load,
},
),
},
),
If(
StmtIf {
range: 5641..5660,
test: Named(
ExprNamed {
range: 5644..5654,
target: Name(
ExprName {
range: 5644..5649,
id: Name("match"),
ctx: Store,
},
),
value: NumberLiteral(
ExprNumberLiteral {
range: 5653..5654,
value: Int(
1,
),
},
),
},
),
body: [
Pass(
StmtPass {
range: 5656..5660,
},
),
],
elif_else_clauses: [],
},
),
Match(
StmtMatch {
range: 5661..5715,
subject: Name(
ExprName {
range: 5667..5672,
id: Name("match"),
ctx: Load,
},
),
cases: [
MatchCase {
range: 5678..5690,
pattern: MatchValue(
PatternMatchValue {
range: 5683..5684,
value: NumberLiteral(
ExprNumberLiteral {
range: 5683..5684,
value: Int(
1,
),
},
),
},
),
guard: None,
body: [
Pass(
StmtPass {
range: 5686..5690,
},
),
],
},
MatchCase {
range: 5695..5715,
pattern: MatchValue(
PatternMatchValue {
range: 5700..5701,
value: NumberLiteral(
ExprNumberLiteral {
range: 5700..5701,
value: Int(
2,
),
},
),
},
),
guard: None,
body: [
Pass(
StmtPass {
range: 5711..5715,
},
),
],
},
],
},
),
Assign(
StmtAssign {
range: 5716..5752,
targets: [
Name(
ExprName {
range: 5716..5721,
id: Name("match"),
ctx: Store,
},
),
],
value: Lambda(
ExprLambda {
range: 5724..5752,
parameters: Some(
Parameters {
range: 5731..5736,
posonlyargs: [],
args: [
ParameterWithDefault {
range: 5731..5736,
parameter: Parameter {
range: 5731..5736,
name: Identifier {
id: Name("query"),
range: 5731..5736,
},
annotation: None,
},
default: None,
},
],
vararg: None,
kwonlyargs: [],
kwarg: None,
},
),
body: Compare(
ExprCompare {
range: 5738..5752,
left: Name(
ExprName {
range: 5738..5743,
id: Name("query"),
ctx: Load,
},
),
ops: [
Eq,
],
comparators: [
Name(
ExprName {
range: 5747..5752,
id: Name("event"),
ctx: Load,
},
),
],
},
),
},
),
},
),
Expr(
StmtExpr {
range: 5753..5769,
value: Call(
ExprCall {
range: 5753..5769,
func: Name(
ExprName {
range: 5753..5758,
id: Name("print"),
ctx: Load,
},
),
arguments: Arguments {
range: 5758..5769,
args: [
Call(
ExprCall {
range: 5759..5768,
func: Name(
ExprName {
range: 5759..5764,
id: Name("match"),
ctx: Load,
},
),
arguments: Arguments {
range: 5764..5768,
args: [
NumberLiteral(
ExprNumberLiteral {
range: 5765..5767,
value: Int(
12,
),
},
),
],
keywords: [],
},
},
),
],
keywords: [],
},
},
),
},
),
],
},
)
```
Reference in a new issue View git blame Copy permalink