mirror of
https://github.com/astral-sh/ruff.git
synced 2025-10-31 03:55:09 +00:00
13ffb5bc19
(Supersedes #9152, authored by @LaBatata101) ## Summary This PR replaces the current parser generated from LALRPOP to a hand-written recursive descent parser. It also updates the grammar for [PEP 646](https://peps.python.org/pep-0646/) so that the parser outputs the correct AST. For example, in `data[*x]`, the index expression is now a tuple with a single starred expression instead of just a starred expression. Beyond the performance improvements, the parser is also error resilient and can provide better error messages. The behavior as seen by any downstream tools isn't changed. That is, the linter and formatter can still assume that the parser will _stop_ at the first syntax error. This will be updated in the following months. For more details about the change here, refer to the PR corresponding to the individual commits and the release blog post. ## Test Plan Write _lots_ and _lots_ of tests for both valid and invalid syntax and verify the output. ## Acknowledgements - @MichaReiser for reviewing 100+ parser PRs and continuously providing guidance throughout the project - @LaBatata101 for initiating the transition to a hand-written parser in #9152 - @addisoncrump for implementing the fuzzer which helped [catch](https://github.com/astral-sh/ruff/pull/10903) [a](https://github.com/astral-sh/ruff/pull/10910) [lot](https://github.com/astral-sh/ruff/pull/10966) [of](https://github.com/astral-sh/ruff/pull/10896) [bugs](https://github.com/astral-sh/ruff/pull/10877) --------- Co-authored-by: Victor Hugo Gomes <labatata101@linuxmail.org> Co-authored-by: Micha Reiser <micha@reiser.io>
1561 lines
92 KiB
Text
1561 lines
92 KiB
Text
---
|
|
source: crates/ruff_python_parser/tests/fixtures.rs
|
|
input_file: crates/ruff_python_parser/resources/valid/statement/try.py
|
|
---
|
|
## AST
|
|
|
|
```
|
|
Module(
|
|
ModModule {
|
|
range: 0..1223,
|
|
body: [
|
|
Try(
|
|
StmtTry {
|
|
range: 0..28,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 9..12,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 9..12,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
handlers: [
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 13..28,
|
|
type_: None,
|
|
name: None,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 25..28,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 25..28,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
],
|
|
orelse: [],
|
|
finalbody: [],
|
|
is_star: false,
|
|
},
|
|
),
|
|
Try(
|
|
StmtTry {
|
|
range: 30..106,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 39..42,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 39..42,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
handlers: [
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 43..74,
|
|
type_: Some(
|
|
Name(
|
|
ExprName {
|
|
range: 50..60,
|
|
id: "Exception1",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
),
|
|
name: Some(
|
|
Identifier {
|
|
id: "e",
|
|
range: 64..65,
|
|
},
|
|
),
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 71..74,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 71..74,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 75..106,
|
|
type_: Some(
|
|
Name(
|
|
ExprName {
|
|
range: 82..92,
|
|
id: "Exception2",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
),
|
|
name: Some(
|
|
Identifier {
|
|
id: "e",
|
|
range: 96..97,
|
|
},
|
|
),
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 103..106,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 103..106,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
],
|
|
orelse: [],
|
|
finalbody: [],
|
|
is_star: false,
|
|
},
|
|
),
|
|
Try(
|
|
StmtTry {
|
|
range: 108..184,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 117..120,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 117..120,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
handlers: [
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 121..151,
|
|
type_: Some(
|
|
Name(
|
|
ExprName {
|
|
range: 128..137,
|
|
id: "Exception",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
),
|
|
name: Some(
|
|
Identifier {
|
|
id: "e",
|
|
range: 141..142,
|
|
},
|
|
),
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 148..151,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 148..151,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 152..167,
|
|
type_: None,
|
|
name: None,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 164..167,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 164..167,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
],
|
|
orelse: [],
|
|
finalbody: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 181..184,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 181..184,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
is_star: false,
|
|
},
|
|
),
|
|
Try(
|
|
StmtTry {
|
|
range: 186..228,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 195..198,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 195..198,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
handlers: [
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 199..214,
|
|
type_: None,
|
|
name: None,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 211..214,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 211..214,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
],
|
|
orelse: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 225..228,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 225..228,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
finalbody: [],
|
|
is_star: false,
|
|
},
|
|
),
|
|
Try(
|
|
StmtTry {
|
|
range: 230..289,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 239..242,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 239..242,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
handlers: [
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 243..258,
|
|
type_: None,
|
|
name: None,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 255..258,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 255..258,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
],
|
|
orelse: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 269..272,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 269..272,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
finalbody: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 286..289,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 286..289,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
is_star: false,
|
|
},
|
|
),
|
|
Try(
|
|
StmtTry {
|
|
range: 291..320,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 300..303,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 300..303,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
handlers: [],
|
|
orelse: [],
|
|
finalbody: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 317..320,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 317..320,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
is_star: false,
|
|
},
|
|
),
|
|
Try(
|
|
StmtTry {
|
|
range: 322..365,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 331..334,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 331..334,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
handlers: [],
|
|
orelse: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 345..348,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 345..348,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
finalbody: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 362..365,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 362..365,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
is_star: false,
|
|
},
|
|
),
|
|
Try(
|
|
StmtTry {
|
|
range: 367..441,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 376..379,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 376..379,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
handlers: [
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 380..409,
|
|
type_: Some(
|
|
Name(
|
|
ExprName {
|
|
range: 388..394,
|
|
id: "GroupA",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
),
|
|
name: Some(
|
|
Identifier {
|
|
id: "eg",
|
|
range: 398..400,
|
|
},
|
|
),
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 406..409,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 406..409,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 410..441,
|
|
type_: Some(
|
|
Name(
|
|
ExprName {
|
|
range: 418..432,
|
|
id: "ExceptionGroup",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
),
|
|
name: None,
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 438..441,
|
|
value: EllipsisLiteral(
|
|
ExprEllipsisLiteral {
|
|
range: 438..441,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
],
|
|
orelse: [],
|
|
finalbody: [],
|
|
is_star: true,
|
|
},
|
|
),
|
|
Try(
|
|
StmtTry {
|
|
range: 443..577,
|
|
body: [
|
|
Raise(
|
|
StmtRaise {
|
|
range: 452..471,
|
|
exc: Some(
|
|
Call(
|
|
ExprCall {
|
|
range: 458..471,
|
|
func: Name(
|
|
ExprName {
|
|
range: 458..468,
|
|
id: "ValueError",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 468..471,
|
|
args: [
|
|
NumberLiteral(
|
|
ExprNumberLiteral {
|
|
range: 469..470,
|
|
value: Int(
|
|
1,
|
|
),
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
),
|
|
cause: None,
|
|
},
|
|
),
|
|
],
|
|
handlers: [
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 472..525,
|
|
type_: Some(
|
|
Name(
|
|
ExprName {
|
|
range: 479..488,
|
|
id: "TypeError",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
),
|
|
name: Some(
|
|
Identifier {
|
|
id: "e",
|
|
range: 492..493,
|
|
},
|
|
),
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 499..525,
|
|
value: Call(
|
|
ExprCall {
|
|
range: 499..525,
|
|
func: Name(
|
|
ExprName {
|
|
range: 499..504,
|
|
id: "print",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 504..525,
|
|
args: [
|
|
FString(
|
|
ExprFString {
|
|
range: 505..524,
|
|
value: FStringValue {
|
|
inner: Single(
|
|
FString(
|
|
FString {
|
|
range: 505..524,
|
|
elements: [
|
|
Literal(
|
|
FStringLiteralElement {
|
|
range: 507..514,
|
|
value: "caught ",
|
|
},
|
|
),
|
|
Expression(
|
|
FStringExpressionElement {
|
|
range: 514..523,
|
|
expression: Call(
|
|
ExprCall {
|
|
range: 515..522,
|
|
func: Name(
|
|
ExprName {
|
|
range: 515..519,
|
|
id: "type",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 519..522,
|
|
args: [
|
|
Name(
|
|
ExprName {
|
|
range: 520..521,
|
|
id: "e",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
debug_text: None,
|
|
conversion: None,
|
|
format_spec: None,
|
|
},
|
|
),
|
|
],
|
|
flags: FStringFlags {
|
|
quote_style: Double,
|
|
prefix: Regular,
|
|
triple_quoted: false,
|
|
},
|
|
},
|
|
),
|
|
),
|
|
},
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 526..577,
|
|
type_: Some(
|
|
Name(
|
|
ExprName {
|
|
range: 533..540,
|
|
id: "OSError",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
),
|
|
name: Some(
|
|
Identifier {
|
|
id: "e",
|
|
range: 544..545,
|
|
},
|
|
),
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 551..577,
|
|
value: Call(
|
|
ExprCall {
|
|
range: 551..577,
|
|
func: Name(
|
|
ExprName {
|
|
range: 551..556,
|
|
id: "print",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 556..577,
|
|
args: [
|
|
FString(
|
|
ExprFString {
|
|
range: 557..576,
|
|
value: FStringValue {
|
|
inner: Single(
|
|
FString(
|
|
FString {
|
|
range: 557..576,
|
|
elements: [
|
|
Literal(
|
|
FStringLiteralElement {
|
|
range: 559..566,
|
|
value: "caught ",
|
|
},
|
|
),
|
|
Expression(
|
|
FStringExpressionElement {
|
|
range: 566..575,
|
|
expression: Call(
|
|
ExprCall {
|
|
range: 567..574,
|
|
func: Name(
|
|
ExprName {
|
|
range: 567..571,
|
|
id: "type",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 571..574,
|
|
args: [
|
|
Name(
|
|
ExprName {
|
|
range: 572..573,
|
|
id: "e",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
debug_text: None,
|
|
conversion: None,
|
|
format_spec: None,
|
|
},
|
|
),
|
|
],
|
|
flags: FStringFlags {
|
|
quote_style: Double,
|
|
prefix: Regular,
|
|
triple_quoted: false,
|
|
},
|
|
},
|
|
),
|
|
),
|
|
},
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
],
|
|
orelse: [],
|
|
finalbody: [],
|
|
is_star: false,
|
|
},
|
|
),
|
|
Try(
|
|
StmtTry {
|
|
range: 579..831,
|
|
body: [
|
|
Raise(
|
|
StmtRaise {
|
|
range: 588..669,
|
|
exc: Some(
|
|
Call(
|
|
ExprCall {
|
|
range: 594..669,
|
|
func: Name(
|
|
ExprName {
|
|
range: 594..608,
|
|
id: "ExceptionGroup",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 608..669,
|
|
args: [
|
|
StringLiteral(
|
|
ExprStringLiteral {
|
|
range: 609..613,
|
|
value: StringLiteralValue {
|
|
inner: Single(
|
|
StringLiteral {
|
|
range: 609..613,
|
|
value: "eg",
|
|
flags: StringLiteralFlags {
|
|
quote_style: Double,
|
|
prefix: Empty,
|
|
triple_quoted: false,
|
|
},
|
|
},
|
|
),
|
|
},
|
|
},
|
|
),
|
|
List(
|
|
ExprList {
|
|
range: 615..668,
|
|
elts: [
|
|
Call(
|
|
ExprCall {
|
|
range: 616..629,
|
|
func: Name(
|
|
ExprName {
|
|
range: 616..626,
|
|
id: "ValueError",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 626..629,
|
|
args: [
|
|
NumberLiteral(
|
|
ExprNumberLiteral {
|
|
range: 627..628,
|
|
value: Int(
|
|
1,
|
|
),
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
Call(
|
|
ExprCall {
|
|
range: 631..643,
|
|
func: Name(
|
|
ExprName {
|
|
range: 631..640,
|
|
id: "TypeError",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 640..643,
|
|
args: [
|
|
NumberLiteral(
|
|
ExprNumberLiteral {
|
|
range: 641..642,
|
|
value: Int(
|
|
2,
|
|
),
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
Call(
|
|
ExprCall {
|
|
range: 645..655,
|
|
func: Name(
|
|
ExprName {
|
|
range: 645..652,
|
|
id: "OSError",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 652..655,
|
|
args: [
|
|
NumberLiteral(
|
|
ExprNumberLiteral {
|
|
range: 653..654,
|
|
value: Int(
|
|
3,
|
|
),
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
Call(
|
|
ExprCall {
|
|
range: 657..667,
|
|
func: Name(
|
|
ExprName {
|
|
range: 657..664,
|
|
id: "OSError",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 664..667,
|
|
args: [
|
|
NumberLiteral(
|
|
ExprNumberLiteral {
|
|
range: 665..666,
|
|
value: Int(
|
|
4,
|
|
),
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
],
|
|
ctx: Load,
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
),
|
|
cause: None,
|
|
},
|
|
),
|
|
],
|
|
handlers: [
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 670..751,
|
|
type_: Some(
|
|
Name(
|
|
ExprName {
|
|
range: 678..687,
|
|
id: "TypeError",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
),
|
|
name: Some(
|
|
Identifier {
|
|
id: "e",
|
|
range: 691..692,
|
|
},
|
|
),
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 698..751,
|
|
value: Call(
|
|
ExprCall {
|
|
range: 698..751,
|
|
func: Name(
|
|
ExprName {
|
|
range: 698..703,
|
|
id: "print",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 703..751,
|
|
args: [
|
|
FString(
|
|
ExprFString {
|
|
range: 704..750,
|
|
value: FStringValue {
|
|
inner: Single(
|
|
FString(
|
|
FString {
|
|
range: 704..750,
|
|
elements: [
|
|
Literal(
|
|
FStringLiteralElement {
|
|
range: 706..713,
|
|
value: "caught ",
|
|
},
|
|
),
|
|
Expression(
|
|
FStringExpressionElement {
|
|
range: 713..722,
|
|
expression: Call(
|
|
ExprCall {
|
|
range: 714..721,
|
|
func: Name(
|
|
ExprName {
|
|
range: 714..718,
|
|
id: "type",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 718..721,
|
|
args: [
|
|
Name(
|
|
ExprName {
|
|
range: 719..720,
|
|
id: "e",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
debug_text: None,
|
|
conversion: None,
|
|
format_spec: None,
|
|
},
|
|
),
|
|
Literal(
|
|
FStringLiteralElement {
|
|
range: 722..735,
|
|
value: " with nested ",
|
|
},
|
|
),
|
|
Expression(
|
|
FStringExpressionElement {
|
|
range: 735..749,
|
|
expression: Attribute(
|
|
ExprAttribute {
|
|
range: 736..748,
|
|
value: Name(
|
|
ExprName {
|
|
range: 736..737,
|
|
id: "e",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
attr: Identifier {
|
|
id: "exceptions",
|
|
range: 738..748,
|
|
},
|
|
ctx: Load,
|
|
},
|
|
),
|
|
debug_text: None,
|
|
conversion: None,
|
|
format_spec: None,
|
|
},
|
|
),
|
|
],
|
|
flags: FStringFlags {
|
|
quote_style: Double,
|
|
prefix: Regular,
|
|
triple_quoted: false,
|
|
},
|
|
},
|
|
),
|
|
),
|
|
},
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 752..831,
|
|
type_: Some(
|
|
Name(
|
|
ExprName {
|
|
range: 760..767,
|
|
id: "OSError",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
),
|
|
name: Some(
|
|
Identifier {
|
|
id: "e",
|
|
range: 771..772,
|
|
},
|
|
),
|
|
body: [
|
|
Expr(
|
|
StmtExpr {
|
|
range: 778..831,
|
|
value: Call(
|
|
ExprCall {
|
|
range: 778..831,
|
|
func: Name(
|
|
ExprName {
|
|
range: 778..783,
|
|
id: "print",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 783..831,
|
|
args: [
|
|
FString(
|
|
ExprFString {
|
|
range: 784..830,
|
|
value: FStringValue {
|
|
inner: Single(
|
|
FString(
|
|
FString {
|
|
range: 784..830,
|
|
elements: [
|
|
Literal(
|
|
FStringLiteralElement {
|
|
range: 786..793,
|
|
value: "caught ",
|
|
},
|
|
),
|
|
Expression(
|
|
FStringExpressionElement {
|
|
range: 793..802,
|
|
expression: Call(
|
|
ExprCall {
|
|
range: 794..801,
|
|
func: Name(
|
|
ExprName {
|
|
range: 794..798,
|
|
id: "type",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
arguments: Arguments {
|
|
range: 798..801,
|
|
args: [
|
|
Name(
|
|
ExprName {
|
|
range: 799..800,
|
|
id: "e",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
debug_text: None,
|
|
conversion: None,
|
|
format_spec: None,
|
|
},
|
|
),
|
|
Literal(
|
|
FStringLiteralElement {
|
|
range: 802..815,
|
|
value: " with nested ",
|
|
},
|
|
),
|
|
Expression(
|
|
FStringExpressionElement {
|
|
range: 815..829,
|
|
expression: Attribute(
|
|
ExprAttribute {
|
|
range: 816..828,
|
|
value: Name(
|
|
ExprName {
|
|
range: 816..817,
|
|
id: "e",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
attr: Identifier {
|
|
id: "exceptions",
|
|
range: 818..828,
|
|
},
|
|
ctx: Load,
|
|
},
|
|
),
|
|
debug_text: None,
|
|
conversion: None,
|
|
format_spec: None,
|
|
},
|
|
),
|
|
],
|
|
flags: FStringFlags {
|
|
quote_style: Double,
|
|
prefix: Regular,
|
|
triple_quoted: false,
|
|
},
|
|
},
|
|
),
|
|
),
|
|
},
|
|
},
|
|
),
|
|
],
|
|
keywords: [],
|
|
},
|
|
},
|
|
),
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
],
|
|
orelse: [],
|
|
finalbody: [],
|
|
is_star: true,
|
|
},
|
|
),
|
|
Try(
|
|
StmtTry {
|
|
range: 833..1075,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 842..846,
|
|
},
|
|
),
|
|
],
|
|
handlers: [
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 847..875,
|
|
type_: Some(
|
|
StringLiteral(
|
|
ExprStringLiteral {
|
|
range: 854..865,
|
|
value: StringLiteralValue {
|
|
inner: Single(
|
|
StringLiteral {
|
|
range: 854..865,
|
|
value: "exception",
|
|
flags: StringLiteralFlags {
|
|
quote_style: Double,
|
|
prefix: Empty,
|
|
triple_quoted: false,
|
|
},
|
|
},
|
|
),
|
|
},
|
|
},
|
|
),
|
|
),
|
|
name: None,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 871..875,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 876..894,
|
|
type_: Some(
|
|
NumberLiteral(
|
|
ExprNumberLiteral {
|
|
range: 883..884,
|
|
value: Int(
|
|
1,
|
|
),
|
|
},
|
|
),
|
|
),
|
|
name: None,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 890..894,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 895..916,
|
|
type_: Some(
|
|
BooleanLiteral(
|
|
ExprBooleanLiteral {
|
|
range: 902..906,
|
|
value: true,
|
|
},
|
|
),
|
|
),
|
|
name: None,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 912..916,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 917..939,
|
|
type_: Some(
|
|
BinOp(
|
|
ExprBinOp {
|
|
range: 924..929,
|
|
left: NumberLiteral(
|
|
ExprNumberLiteral {
|
|
range: 924..925,
|
|
value: Int(
|
|
1,
|
|
),
|
|
},
|
|
),
|
|
op: Add,
|
|
right: NumberLiteral(
|
|
ExprNumberLiteral {
|
|
range: 928..929,
|
|
value: Int(
|
|
1,
|
|
),
|
|
},
|
|
),
|
|
},
|
|
),
|
|
),
|
|
name: None,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 935..939,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 940..962,
|
|
type_: Some(
|
|
BinOp(
|
|
ExprBinOp {
|
|
range: 947..952,
|
|
left: Name(
|
|
ExprName {
|
|
range: 947..948,
|
|
id: "a",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
op: BitOr,
|
|
right: Name(
|
|
ExprName {
|
|
range: 951..952,
|
|
id: "b",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
),
|
|
name: None,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 958..962,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 963..987,
|
|
type_: Some(
|
|
BoolOp(
|
|
ExprBoolOp {
|
|
range: 970..977,
|
|
op: And,
|
|
values: [
|
|
Name(
|
|
ExprName {
|
|
range: 970..971,
|
|
id: "x",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
Name(
|
|
ExprName {
|
|
range: 976..977,
|
|
id: "y",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
),
|
|
name: None,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 983..987,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 988..1012,
|
|
type_: Some(
|
|
Await(
|
|
ExprAwait {
|
|
range: 995..1002,
|
|
value: Name(
|
|
ExprName {
|
|
range: 1001..1002,
|
|
id: "x",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
),
|
|
name: None,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 1008..1012,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 1013..1041,
|
|
type_: Some(
|
|
Lambda(
|
|
ExprLambda {
|
|
range: 1020..1031,
|
|
parameters: Some(
|
|
Parameters {
|
|
range: 1027..1028,
|
|
posonlyargs: [],
|
|
args: [
|
|
ParameterWithDefault {
|
|
range: 1027..1028,
|
|
parameter: Parameter {
|
|
range: 1027..1028,
|
|
name: Identifier {
|
|
id: "x",
|
|
range: 1027..1028,
|
|
},
|
|
annotation: None,
|
|
},
|
|
default: None,
|
|
},
|
|
],
|
|
vararg: None,
|
|
kwonlyargs: [],
|
|
kwarg: None,
|
|
},
|
|
),
|
|
body: Name(
|
|
ExprName {
|
|
range: 1030..1031,
|
|
id: "x",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
),
|
|
name: None,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 1037..1041,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
ExceptHandler(
|
|
ExceptHandlerExceptHandler {
|
|
range: 1042..1075,
|
|
type_: Some(
|
|
If(
|
|
ExprIf {
|
|
range: 1049..1065,
|
|
test: BooleanLiteral(
|
|
ExprBooleanLiteral {
|
|
range: 1054..1058,
|
|
value: true,
|
|
},
|
|
),
|
|
body: Name(
|
|
ExprName {
|
|
range: 1049..1050,
|
|
id: "x",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
orelse: Name(
|
|
ExprName {
|
|
range: 1064..1065,
|
|
id: "y",
|
|
ctx: Load,
|
|
},
|
|
),
|
|
},
|
|
),
|
|
),
|
|
name: None,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 1071..1075,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
),
|
|
],
|
|
orelse: [],
|
|
finalbody: [],
|
|
is_star: false,
|
|
},
|
|
),
|
|
If(
|
|
StmtIf {
|
|
range: 1077..1222,
|
|
test: BooleanLiteral(
|
|
ExprBooleanLiteral {
|
|
range: 1080..1084,
|
|
value: true,
|
|
},
|
|
),
|
|
body: [
|
|
Try(
|
|
StmtTry {
|
|
range: 1090..1133,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 1103..1107,
|
|
},
|
|
),
|
|
],
|
|
handlers: [],
|
|
orelse: [],
|
|
finalbody: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 1129..1133,
|
|
},
|
|
),
|
|
],
|
|
is_star: false,
|
|
},
|
|
),
|
|
],
|
|
elif_else_clauses: [
|
|
ElifElseClause {
|
|
range: 1208..1222,
|
|
test: None,
|
|
body: [
|
|
Pass(
|
|
StmtPass {
|
|
range: 1218..1222,
|
|
},
|
|
),
|
|
],
|
|
},
|
|
],
|
|
},
|
|
),
|
|
],
|
|
},
|
|
)
|
|
```
|