pfff 0.39.5 · OCaml Package

type tok = Parse_info.t

type 'a wrap = 'a * tok

type name = string wrap

type dotted_name = name list

type resolved_name =

| LocalVar
| Parameter
| GlobalVar
| ClassField
| ImportedModule of dotted_name
| ImportedEntity of dotted_name
| NotResolved

type expr =

| Num of number
| Str of string wrap
| Bool of bool wrap
| None_ of tok
| Name of name * expr_context * resolved_name ref
| Tuple of expr list_or_comprehension * expr_context
| List of expr list_or_comprehension * expr_context
| DictOrSet of dictorset_elt list_or_comprehension
| ExprStar of expr
| InterpolatedString of interpolated list
| TypedExpr of expr * type_
| Ellipses of tok
| BoolOp of boolop wrap * expr list
| BinOp of expr * operator wrap * expr
| UnaryOp of unaryop wrap * expr
| Compare of expr * cmpop wrap list * expr list
| Call of expr * argument list
| Subscript of expr * slice list * expr_context
| Lambda of parameters * expr
| IfExp of expr * expr * expr
| Yield of expr option
| Await of expr
| Repr of expr
| Attribute of expr * name * expr_context

and number =

| Int of string wrap
| LongInt of string wrap
| Float of string wrap
| Imag of string wrap

and boolop =

| And
| Or

and operator =

| Add
| Sub
| Mult
| Div
| Mod
| Pow
| FloorDiv
| LShift
| RShift
| BitOr
| BitXor
| BitAnd

and unaryop =

| Invert
| Not
| UAdd
| USub

and cmpop =

| Eq
| NotEq
| Lt
| LtE
| Gt
| GtE
| Is
| IsNot
| In
| NotIn

and interpolated = expr

and 'a list_or_comprehension =

| CompList of 'a list
| CompForIf of 'a comprehension

and 'a comprehension = 'a * for_if list

and for_if =

| CompFor of expr * expr
| CompIf of expr

and dictorset_elt =

| KeyVal of expr * expr
| Key of expr
| PowInline of expr

and expr_context =

| Load
| Store
| Del
| AugLoad
| AugStore
| Param

and slice =

| Slice of expr option * expr option * expr option
| Index of expr

and parameters = parameter list

and parameter =

| ParamClassic of name * type_ option * expr option
| ParamStar of name * type_ option
| ParamPow of name * type_ option

and argument =

| Arg of expr
| ArgKwd of name * expr
| ArgStar of expr
| ArgPow of expr
| ArgComp of expr * for_if list

and type_ = expr

and type_parent = argument

type pattern = expr

type stmt =

| ExprStmt of expr
| Assign of expr list * expr
| AugAssign of expr * operator wrap * expr
| For of pattern * expr * stmt list * stmt list
| While of expr * stmt list * stmt list
| If of expr * stmt list * stmt list
| With of expr * expr option * stmt list
| Return of expr option
| Break
| Continue
| Pass
| Raise of (expr * expr option) option
| TryExcept of stmt list * excepthandler list * stmt list
| TryFinally of stmt list * stmt list
| Assert of expr * expr option
| Global of name list
| Delete of expr list
| NonLocal of name list
| Async of stmt
| Import of alias_dotted list
| ImportFrom of dotted_name * alias list * int option
| FunctionDef of name * parameters * type_ option * stmt list * decorator list
| ClassDef of name * type_parent list * stmt list * decorator list

and excepthandler =

| ExceptHandler of type_ option * expr option * stmt list

and decorator = expr

and alias = name * name option

and alias_dotted = dotted_name * name option

type program = stmt list

type any =

| Expr of expr
| Stmt of stmt
| Stmts of stmt list
| Program of program
| DictElem of dictorset_elt

val str_of_name : ('a * 'b) -> 'a

val context_of_expr : expr -> expr_context option

package pfff