TaglessFinal.Statement
This module provides a type that represents a Python statement.
type ('alias, 'arguments, 'bin_op, 'except_handler, 'expr, 'identifier, 'keyword, 'location, 'match_case, 'type_param, 'with_item, 'stmt)
t =
private {
function_def : location:'location ->
name:'identifier ->
args:'arguments ->
body:'stmt list ->
decorator_list:'expr list ->
returns:'expr option ->
type_comment:string option ->
type_params:'type_param list ->
'stmt;
Represent a function definition (i.e. def
) statement.
name
is the name of the function.args
is the argument list of the function (see Arguments
).body
is the body of the function.decorator_list
is the list of decorators applied to the function.returns
is the (optionally specified) return annotation.type_comment
is the Py2-style type comment for the function (see Parser.TaglessFinal.parse_function_type
).type_params
(optionally) specifies what type variables this function is generic against (see TypeParam
).async_function_def : location:'location ->
name:'identifier ->
args:'arguments ->
body:'stmt list ->
decorator_list:'expr list ->
returns:'expr option ->
type_comment:string option ->
type_params:'type_param list ->
'stmt;
Represent an async function definition (i.e. async def
) statement. It has exactly the same set of fields as def
statement.
class_def : location:'location ->
name:'identifier ->
bases:'expr list ->
keywords:'keyword list ->
body:'stmt list ->
decorator_list:'expr list ->
type_params:'type_param list ->
'stmt;
Represent a class definition (i.e. class
) statement.
name
is the name of the class.bases
is the positional arguments of the class' argument list (e.g. the Bar
part in class Foo(Bar): ...
).keywords
is the keyword arguments of the class' argument list (e.g. the metaclass=FooMeta
part in class Foo(metaclass=FooMeta): ...
). This is mainly used for metaclasses (see PEP 3115) but can also be used for other customizations of class creation (see PEP 487).body
is the body of the class.decorator_list
is the list of decorators applied to the function.type_params
(optionally) specifies what type variables this function is generic against (see TypeParam
).return : location:'location -> value:'expr option -> 'stmt;
Represent a return
statement.
value
is the (optionally specified) return value.delete : location:'location -> targets:'expr list -> 'stmt;
Represent a delete
statement.
targets
is the values to delete (guaranteed by CPython parser to be non-empty). Deletion can only be one of a selected few kinds of expressions, and the corresponding expression context will always be set to ExpressionContext.t.del
. See documentation of ExpressionContext
for more details of which expressions are allowed.assign : location:'location ->
targets:'expr list ->
value:'expr ->
type_comment:string option ->
'stmt;
Represent an unannotated assignment statement.
targets
is the variables/attributes/subscripts to assign to (guaranteed by CPython parser to be non-empty). Assignment target can only be one of a selected few kinds of expressions, and the corresponding expression context will always be set to ExpressionContext.t.store
. See documentation of ExpressionContext
for more details of which expressions are allowed.value
is the value to be assigned to targets
, i.e. the "right-hand-side" of the assignment.type_comment
is the Py2-style type comment annotation for targets
. Note that if targets
contains more than one element, then type comment is the only possible way to specify the annotation for targets
as the ann_assign
statement only supports inline annotation for a single target.type_alias : location:'location ->
name:'expr ->
type_params:'type_param list ->
value:'expr ->
'stmt;
Represent a type alias statement. (see PEP 695)
name
is the name of the alias being assigned to. It's marked as an expression but in CPython implementation, it's always going to be an Expression.t.name
with context set to ExpressionContext.t.store
.type_params
is the list of type variables this alias is generic against. For simple non-generic type alias definitions this is always going to be empty list.value
is the type to be assigned to name
, i.e. the "right-hand-side" of the alias definition.aug_assign : location:'location ->
target:'expr ->
op:'bin_op ->
value:'expr ->
'stmt;
Represent an augmented assignment statement (see PEP 203).
target
is the variable/attribute/subscript to assign to. Assignment target can only be one of a selected few kinds of expressions, and the corresponding expression context will always be set to ExpressionContext.t.store
. See documentation of ExpressionContext
for more details of which expressions are allowed.value
is the value that will be used to compute what needs to be assigned to target
. For an augmented assignment x op= y
, then "right-hand-side" of the assignment is computed as x op y
.ann_assign : location:'location ->
target:'expr ->
annotation:'expr ->
value:'expr option ->
simple:bool ->
'stmt;
Represent an annotated assignment statement (see PEP 526).
target
is the variable/attribute/subscript to assign to. Assignment target can only be one of a selected few kinds of expressions, and the corresponding expression context will always be set to ExpressionContext.t.store
. See documentation of ExpressionContext
for more details of which expressions are allowed.value
is the value to be assigned to target
, i.e. the "right-hand-side" of the assignment. It can be unset (e.g. x: int
), in which case the statement will only serve annotation purpose.simple
is set to true
when target
is a name
expression that do not appear in between parenthesis, and false
otherwise.for_ : location:'location ->
target:'expr ->
iter:'expr ->
body:'stmt list ->
orelse:'stmt list ->
type_comment:string option ->
'stmt;
Represent a for
statement.
target
is the "index variable" of the statement. It can only be one of a selected few kinds of expressions, and the corresponding expression context will always be set to ExpressionContext.t.store
. See documentation of ExpressionContext
for more details of which expressions are allowed.iter
is the expression that is being iterated on.body
is the body of the loop.orelse
is the list of statements that will be executed when the loop finishes.type_comment
is the Py2-style type comment annotation for target
. Note that type comment is the only possible way to directly specify the annotation for targets
. Achieving the same result with inline type annotation requires one to precede the loop with an annotation-only ann_assign
statement.async_for : location:'location ->
target:'expr ->
iter:'expr ->
body:'stmt list ->
orelse:'stmt list ->
type_comment:string option ->
'stmt;
Represent an async for
statement. It has exactly the same set of fields as for
statement.
while_ : location:'location ->
test:'expr ->
body:'stmt list ->
orelse:'stmt list ->
'stmt;
Represent a while
statement.
test
is the loop condition.body
is the body of the loop.orelse
is the list of statements that will be executed when the loop finishes.if_ : location:'location ->
test:'expr ->
body:'stmt list ->
orelse:'stmt list ->
'stmt;
Represent a if
statement.
test
is the branch condition.body
is the true-branch of the loop.orelse
is the false-branch of the loop.with_ : location:'location ->
items:'with_item list ->
body:'stmt list ->
type_comment:string option ->
'stmt;
Represent a with
statement. See PEP 343.
items
is the "context expression" which will be evaluated to obtain a context manager.body
is the body of the with
block.type_comment
is the Py2-style type comment annotation for all targets in the with items. Note that type comment is the only possible way to directly specify the annotation for targets
. Achieving the same result with inline type annotation requires one to precede the with block with annotation-only ann_assign
statements.async_with : location:'location ->
items:'with_item list ->
body:'stmt list ->
type_comment:string option ->
'stmt;
Represent an async with
statement. It has exactly the same set of fields as with
statement.
match_ : location:'location ->
subject:'expr ->
cases:'match_case list ->
'stmt;
raise_ : location:'location -> exc:'expr option -> cause:'expr option -> 'stmt;
Represent a raise
statement.
exc
is the exception to raise. It can be left unset, in which case Python runtime will re-raise the "last" exception that was just caught.cause
is set if one specify the "from" clause. For example, raise x from y
will set cause
to y
, making the Python runtime attach y
to the __cause__
field of x
.try_ : location:'location ->
body:'stmt list ->
handlers:'except_handler list ->
orelse:'stmt list ->
finalbody:'stmt list ->
'stmt;
Represent a try...except
statement.
body
is the body of the try block, i.e. the logic to run in the normal case.handlers
is a list of exception handlers, specifying the logic to run in the exceptional cases.orelse
is the list of statements that will be executed when the body finishes without having any exception raised and without early return/continue/break.finalbody
is the list of statements that is guaranteed to be executed when execution leaves the try block, regardless of whether an exception occured or not.try_star : location:'location ->
body:'stmt list ->
handlers:'except_handler list ->
orelse:'stmt list ->
finalbody:'stmt list ->
'stmt;
Represent a try...except*
statement. See PEP 654.
Arguments here means the same thing as the try...except
statement, except that the handlers
part should be interpreted as catching&handling exception groups.
assert_ : location:'location -> test:'expr -> msg:'expr option -> 'stmt;
Represent an assert
statement.
test
is condition to assert on.msg
is an (optionally specified) argument that will be passed to the AssertionError
being raised by the Python runtime, if the assertion fails.import : location:'location -> names:'alias list -> 'stmt;
Represent an import
statement.
name
is the list of module names to import.import_from : location:'location ->
module_:'identifier option ->
names:'alias list ->
level:int ->
'stmt;
Represent a from ... import ...
statement.
module_
is the name of the module from which we want to import. It can be left unset, when no module name is specified (e.g. from . import X
).names
is the list of names to import to the current module.level
is an integer holding the level of the relative import (i.e. the number of dots in the import target).global : location:'location -> names:'identifier list -> 'stmt;
Represent a global
statement.
names
is a list of names in the current block to declare as global.nonlocal : location:'location -> names:'identifier list -> 'stmt;
Represent a nonlocal
statement. See PEP 3104.
names
is a list of names in the current block to declare as nonlocal.expr : location:'location -> value:'expr -> 'stmt;
Represent an expression statement.
value
holds the expression (usually with side-effects) that will be evaluated.pass : location:'location -> 'stmt;
Represent a pass
statement.
break : location:'location -> 'stmt;
Represent a break
statement.
continue : location:'location -> 'stmt;
Represent a continue
statement.
}
val make :
function_def:
(location:'a ->
name:'b ->
args:'c ->
body:'d list ->
decorator_list:'e list ->
returns:'e option ->
type_comment:string option ->
type_params:'f list ->
'd) ->
async_function_def:
(location:'a ->
name:'b ->
args:'c ->
body:'d list ->
decorator_list:'e list ->
returns:'e option ->
type_comment:string option ->
type_params:'f list ->
'd) ->
class_def:
(location:'a ->
name:'b ->
bases:'e list ->
keywords:'g list ->
body:'d list ->
decorator_list:'e list ->
type_params:'f list ->
'd) ->
return:(location:'a -> value:'e option -> 'd) ->
delete:(location:'a -> targets:'e list -> 'd) ->
assign:
(location:'a ->
targets:'e list ->
value:'e ->
type_comment:string option ->
'd) ->
type_alias:(location:'a -> name:'e -> type_params:'f list -> value:'e -> 'd) ->
aug_assign:(location:'a -> target:'e -> op:'h -> value:'e -> 'd) ->
ann_assign:
(location:'a ->
target:'e ->
annotation:'e ->
value:'e option ->
simple:bool ->
'd) ->
for_:
(location:'a ->
target:'e ->
iter:'e ->
body:'d list ->
orelse:'d list ->
type_comment:string option ->
'd) ->
async_for:
(location:'a ->
target:'e ->
iter:'e ->
body:'d list ->
orelse:'d list ->
type_comment:string option ->
'd) ->
while_:(location:'a -> test:'e -> body:'d list -> orelse:'d list -> 'd) ->
if_:(location:'a -> test:'e -> body:'d list -> orelse:'d list -> 'd) ->
with_:
(location:'a ->
items:'i list ->
body:'d list ->
type_comment:string option ->
'd) ->
async_with:
(location:'a ->
items:'i list ->
body:'d list ->
type_comment:string option ->
'd) ->
match_:(location:'a -> subject:'e -> cases:'j list -> 'd) ->
raise_:(location:'a -> exc:'e option -> cause:'e option -> 'd) ->
try_:
(location:'a ->
body:'d list ->
handlers:'k list ->
orelse:'d list ->
finalbody:'d list ->
'd) ->
try_star:
(location:'a ->
body:'d list ->
handlers:'k list ->
orelse:'d list ->
finalbody:'d list ->
'd) ->
assert_:(location:'a -> test:'e -> msg:'e option -> 'd) ->
import:(location:'a -> names:'l list -> 'd) ->
import_from:
(location:'a -> module_:'b option -> names:'l list -> level:int -> 'd) ->
global:(location:'a -> names:'b list -> 'd) ->
nonlocal:(location:'a -> names:'b list -> 'd) ->
expr:(location:'a -> value:'e -> 'd) ->
pass:(location:'a -> 'd) ->
break:(location:'a -> 'd) ->
continue:(location:'a -> 'd) ->
unit ->
('l, 'c, 'h, 'k, 'e, 'b, 'g, 'a, 'j, 'f, 'i, 'd) t
Constructor of t
.