package pfff

You can search for identifiers within the package.

in-package search v0.2.0

package pfff

pfff-matcher

Legend:
Library
Module
Module type
Parameter
Class
Class type

type tok = Parse_info.t

type 'a wrap = 'a * tok

type ident = string wrap

type dotted_ident = ident list

type qualifier = dotted_ident

type module_name =

| FileName of string wrap
| DottedName of dotted_ident

type resolved_name =

| Local
| Param
| Global of dotted_ident
| NotResolved
| Macro
| EnumConstant
| ImportedModule of dotted_ident

type name = ident * id_info

and id_info = {

id_qualifier : qualifier option;
id_typeargs : type_arguments option;
id_resolved : resolved_name ref;
id_type : type_ option ref;

}

and expr =

| L of literal
| Container of container_operator * expr list
| Tuple of expr list
| Record of field list
| Constructor of name * expr list
| Lambda of function_definition
| AnonClass of class_definition
| Nop
| Name of name
| IdSpecial of special wrap
| Call of expr * arguments
| Xml of xml
| Assign of expr * expr
| AssignOp of expr * arithmetic_operator wrap * expr
| LetPattern of pattern * expr
| ObjAccess of expr * ident
| ArrayAccess of expr * expr
| Conditional of expr * expr * expr
| MatchPattern of expr * action list
| Yield of expr
| Await of expr
| Cast of type_ * expr
| Seq of expr list
| Ref of expr
| DeRef of expr
| Ellipses of tok
| OtherExpr of other_expr_operator * any list

and literal =

| Bool of bool wrap
| Int of string wrap
| Float of string wrap
| Char of string wrap
| String of string wrap
| Regexp of string wrap
| Unit of tok
| Null of tok
| Undefined of tok

and container_operator =

| Array
| List
| Set
| Dict

and special =

| This
| Super
| Self
| Parent
| Eval
| Typeof
| Instanceof
| Sizeof
| New
| Concat
| Spread
| ArithOp of arithmetic_operator
| IncrDecr of incr_decr * prefix_postfix

and arithmetic_operator =

| Plus
| Minus
| Mult
| Div
| Mod
| Pow
| FloorDiv
| LSL
| LSR
| ASR
| BitOr
| BitXor
| BitAnd
| BitNot
| And
| Or
| Xor
| Not
| Eq
| NotEq
| PhysEq
| NotPhysEq
| Lt
| LtE
| Gt
| GtE

and incr_decr =

| Incr
| Decr

and prefix_postfix =

| Prefix
| Postfix

and action = pattern * expr

and xml = any list

and arguments = argument list

and argument =

| Arg of expr
| ArgKwd of ident * expr
| ArgType of type_
| ArgOther of other_argument_operator * any list

and other_argument_operator =

| OA_ArgPow
| OA_ArgComp
| OA_ArgQuestion

and other_expr_operator =

| OE_Exports
| OE_Module
| OE_Define
| OE_Arguments
| OE_NewTarget
| OE_Delete
| OE_YieldStar
| OE_Encaps
| OE_Require
| OE_UseStrict
| OE_ObjAccess_PN_Computed
| OE_Imag
| OE_Is
| OE_IsNot
| OE_In
| OE_NotIn
| OE_Invert
| OE_Slice
| OE_SliceIndex
| OE_SliceRange
| OE_CompForIf
| OE_CompFor
| OE_CompIf
| OE_CmpOps
| OE_Repr
| OE_NameOrClassType
| OE_ClassLiteral
| OE_NewQualifiedClass
| OE_GetRefLabel
| OE_ArrayInitDesignator
| OE_GccConstructor
| OE_Unpack
| OE_FieldAccessQualified
| OE_RecordWith
| OE_StmtExpr

and stmt =

| ExprStmt of expr
| DefStmt of definition
| DirectiveStmt of directive
| Block of stmt list
| If of expr * stmt * stmt
| While of expr * stmt
| DoWhile of stmt * expr
| For of for_header * stmt
| Switch of expr * case_and_body list
| Return of expr
| Continue of expr option
| Break of expr option
| Label of label * stmt
| Goto of label
| Throw of expr
| Try of stmt * catch list * finally option
| Assert of expr * expr option
| OtherStmt of other_stmt_operator * any list

and case_and_body = case list * stmt

and case =

| Case of expr
| Default

and catch = pattern * stmt

and finally = stmt

and label = ident

and for_header =

| ForClassic of for_var_or_expr list * expr * expr
| ForEach of pattern * expr

and for_var_or_expr =

| ForInitVar of entity * variable_definition
| ForInitExpr of expr

and other_stmt_operator =

| OS_Delete
| OS_ForOrElse
| OS_WhileOrElse
| OS_TryOrElse
| OS_With
| OS_ThrowFrom
| OS_ThrowNothing
| OS_Global
| OS_NonLocal
| OS_Pass
| OS_Async
| OS_Sync
| OS_Asm

and pattern =

| PatLiteral of literal
| PatConstructor of name * pattern list
| PatRecord of field_pattern list
| PatVar of ident
| PatTuple of pattern list
| PatList of pattern list
| PatKeyVal of pattern * pattern
| PatUnderscore of tok
| PatDisj of pattern * pattern
| PatTyped of pattern * type_
| PatWhen of pattern * expr
| PatAs of pattern * ident
| OtherPat of other_pattern_operator * any list

and field_pattern = name * pattern

and other_pattern_operator =

| OP_Expr
| OP_Var

and type_ =

| TyBuiltin of string wrap
| TyFun of type_ list * type_
| TyApply of name * type_arguments
| TyVar of ident
| TyArray of expr option * type_
| TyPointer of type_
| TyTuple of type_ list
| TyQuestion of type_
| OtherType of other_type_operator * any list

and type_arguments = type_argument list

and type_argument =

| TypeArg of type_
| OtherTypeArg of other_type_argument_operator * any list

and other_type_argument_operator =

| OTA_Question

and other_type_operator =

| OT_Expr
| OT_Arg
| OT_StructName
| OT_UnionName
| OT_EnumName
| OT_Shape
| OT_Variadic

and attribute =

| Static
| Volatile
| Extern
| Public
| Private
| Protected
| Abstract
| Final
| Var
| Let
| Mutable
| Const
| Generator
| Async
| Recursive
| MutuallyRecursive
| Ctor
| Dtor
| Getter
| Setter
| Variadic
| NamedAttr of ident * any list
| OtherAttribute of other_attribute_operator * any list

and other_attribute_operator =

| OA_StrictFP
| OA_Transient
| OA_Synchronized
| OA_Native
| OA_AnnotJavaOther
| OA_AnnotThrow
| OA_Expr

and definition = entity * definition_kind

and entity = {

name : ident;
attrs : attribute list;
type_ : type_ option;
tparams : type_parameter list;

}

and definition_kind =

| FuncDef of function_definition
| VarDef of variable_definition
| TypeDef of type_definition
| ClassDef of class_definition
| ModuleDef of module_definition
| MacroDef of macro_definition
| Signature of type_

and type_parameter = ident * type_parameter_constraints

and type_parameter_constraints = type_parameter_constraint list

and type_parameter_constraint =

| Extends of type_

and function_definition = {

fparams : parameters;
frettype : type_ option;
fbody : stmt;

}

and parameters = parameter list

and parameter =

| ParamClassic of parameter_classic
| ParamPattern of pattern
| OtherParam of other_parameter_operator * any list

and parameter_classic = {

pname : ident;
pdefault : expr option;
ptype : type_ option;
pattrs : attribute list;

}

and other_parameter_operator =

| OPO_KwdParam
| OPO_Ref

and variable_definition = {

vinit : expr option;
vtype : type_ option;

}

and type_definition = {

tbody : type_definition_kind;

}

and type_definition_kind =

| OrType of or_type_element list
| AndType of field list
| AliasType of type_
| Exception of ident * type_ list
| OtherTypeKind of other_type_kind_operator * any list

and or_type_element =

| OrConstructor of ident * type_ list
| OrEnum of ident * expr
| OrUnion of ident * type_
| OtherOr of other_or_type_element_operator * any list

and other_or_type_element_operator =

| OOTEO_EnumWithMethods
| OOTEO_EnumWithArguments

and field =

| FieldVar of entity * variable_definition
| FieldMethod of entity * function_definition
| FieldDynamic of expr * attribute list * expr
| FieldSpread of expr
| FieldStmt of stmt

and other_type_kind_operator =

| OTKO_EnumWithValue
| OTKO_AbstractType

and class_definition = {

ckind : class_kind;
cextends : type_ list;
cimplements : type_ list;
cbody : field list;

}

and class_kind =

| Class
| Interface
| Trait

and module_definition = {

mbody : module_definition_kind;

}

and module_definition_kind =

| ModuleAlias of name
| ModuleStruct of dotted_ident option * item list
| OtherModule of other_module_operator * any list

and other_module_operator =

| OMO_Functor

and macro_definition = {

macroparams : ident list;
macrobody : any list;

}

and directive =

| Import of module_name * alias list
| ImportAll of module_name * ident option
| OtherDirective of other_directive_operator * any list

and alias = ident * ident option

and other_directive_operator =

| OI_Export
| OI_ImportCss
| OI_ImportEffect

and item =

| IStmt of stmt
| IDef of definition
| IDir of directive

and program = item list

and any =

| Id of ident
| N of name
| En of entity
| E of expr
| S of stmt
| T of type_
| P of pattern
| Def of definition
| Dir of directive
| I of item
| Pa of parameter
| Ar of argument
| At of attribute
| Dk of definition_kind
| Di of dotted_ident
| Pr of program

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

exception Error of string * Parse_info.t

val error : Parse_info.t -> string -> 'a

val empty_info : unit -> id_info

val basic_param : ident -> parameter_classic

val basic_entity : ident -> attribute list -> entity

val basic_field : ident -> type_ option -> field

val empty_var : unit -> variable_definition

val expr_to_arg : expr -> argument

val entity_to_param : entity -> parameter_classic

val opt_to_nop : expr option -> expr

val opt_to_name : (string * Parse_info.t) option -> string * Parse_info.t

val stmt1 : stmt list -> stmt

val stmt_to_field : stmt -> field

val stmt_to_item : stmt -> item