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

module PI = Parse_info

type tok = Parse_info.info

and 'a wrap = 'a * tok

and 'a paren = tok * 'a * tok

and 'a brace = tok * 'a * tok

and 'a bracket = tok * 'a * tok

and 'a angle = tok * 'a * tok

and 'a comma_list = ('a, tok) Common.either list

and sc = tok option

type name = string wrap

type xhp_tag = string

type module_path = string wrap

type expr =

| L of literal
| V of name
| This of tok
| Super of tok
| U of unop wrap * expr
| B of expr * binop wrap * expr
| Period of expr * tok * name
| Bracket of expr * expr bracket
| Object of property comma_list brace
| Array of expr comma_list bracket
| Apply of expr * expr comma_list paren
| Conditional of expr * tok * expr * tok * expr
| Assign of expr * assignment_operator wrap * expr
| Seq of expr * tok * expr
| Function of func_decl
| Class of class_decl
| Arrow of arrow_func
| Yield of tok * tok option * expr option
| Await of tok * expr
| NewTarget of tok * tok * tok
| Encaps of name option * tok * encaps list * tok
| XhpHtml of xhp_html
| Paren of expr paren

and literal =

| Bool of bool wrap
| Num of string wrap
| String of string wrap
| Regexp of string wrap
| Null of tok

and unop =

| U_new
| U_delete
| U_typeof
| U_void
| U_pre_increment
| U_pre_decrement
| U_post_increment
| U_post_decrement
| U_plus
| U_minus
| U_not
| U_bitnot
| U_spread

and binop =

| B_instanceof
| B_in
| B_add
| B_sub
| B_mul
| B_div
| B_mod
| B_expo
| B_le
| B_ge
| B_lt
| B_gt
| B_lsr
| B_asr
| B_lsl
| B_equal
| B_notequal
| B_physequal
| B_physnotequal
| B_bitand
| B_bitor
| B_bitxor
| B_and
| B_or

and assignment_operator =

| A_eq
| A_add
| A_sub
| A_mul
| A_div
| A_mod
| A_lsl
| A_lsr
| A_asr
| A_and
| A_or
| A_xor

and property =

| P_field of property_name * tok * expr
| P_method of func_decl
| P_shorthand of name
| P_spread of tok * expr

and property_name =

| PN_Id of name
| PN_String of string wrap
| PN_Num of string wrap
| PN_Computed of expr bracket

and xhp_html =

| Xhp of xhp_tag wrap * xhp_attribute list * tok * xhp_body list * xhp_tag option wrap
| XhpSingleton of xhp_tag wrap * xhp_attribute list * tok

and xhp_attribute =

| XhpAttrValue of xhp_attr_name * tok * xhp_attr_value
| XhpAttrNoValue of xhp_attr_name
| XhpAttrSpread of (tok * expr) brace

and xhp_attr_name = string wrap

and xhp_attr_value =

| XhpAttrString of string wrap
| XhpAttrExpr of expr brace

and xhp_body =

| XhpText of string wrap
| XhpExpr of expr option brace
| XhpNested of xhp_html

and encaps =

| EncapsString of string wrap
| EncapsExpr of tok * expr * tok

and stmt =

| VarsDecl of var_kind wrap * var_binding comma_list * sc
| Block of item list brace
| Nop of sc
| ExprStmt of expr * sc
| If of tok * expr paren * stmt * (tok * stmt) option
| Do of tok * stmt * tok * expr paren * sc
| While of tok * expr paren * stmt
| For of tok * tok * lhs_or_vars option * tok * expr option * tok * expr option * tok * stmt
| ForIn of tok * tok * lhs_or_var * tok * expr * tok * stmt
| ForOf of tok * tok * lhs_or_var * tok * expr * tok * stmt
| Switch of tok * expr paren * case_clause list brace
| Continue of tok * label option * sc
| Break of tok * label option * sc
| Return of tok * expr option * sc
| With of tok * expr paren * stmt
| Labeled of label * tok * stmt
| Throw of tok * expr * sc
| Try of tok * stmt * (tok * arg_catch paren * stmt) option * (tok * stmt) option

and label = string wrap

and lhs_or_vars =

| LHS1 of expr
| ForVars of var_kind wrap * var_binding comma_list

and lhs_or_var =

| LHS2 of expr
| ForVar of var_kind wrap * var_binding

and case_clause =

| Default of tok * tok * item list
| Case of tok * expr * tok * item list

and arg_catch = string wrap

and type_ =

| TName of nominal_type
| TQuestion of tok * type_
| TFun of param_types * tok * type_
| TObj of obj_type_member list brace
| TTodo

and nominal_type = expr * type_argument comma_list angle option

and param_types = (param_name * annotation) comma_list paren

and param_name =

| RequiredParam of name
| OptionalParam of name * tok
| RestParam of tok * name

and obj_type_member = property_name * annotation * sc

and type_argument = type_

and type_parameters = type_parameter comma_list angle

and type_parameter = name

and type_opt = annotation option

and annotation =

| TAnnot of tok * type_
| TFunAnnot of type_parameters option * param_types * tok * type_

and func_decl = {

f_kind : func_kind;
f_properties : func_property list;
f_params : parameter_binding comma_list paren;
f_body : item list brace;
f_type_params : type_parameters option;
f_return_type : type_opt;

}

and func_kind =

| F_func of tok * name option
| F_method of property_name
| F_get of tok * property_name
| F_set of tok * property_name

and func_property =

| Generator of tok
| Async of tok

and parameter_binding =

| ParamClassic of parameter
| ParamPattern of parameter_pattern

and parameter = {

p_name : name;
p_type : type_opt;
p_default : default option;
p_dots : tok option;

}

and default =

| DNone of tok
| DSome of tok * expr

and parameter_pattern = {

ppat : pattern;
ppat_type : type_opt;
ppat_default : (tok * expr) option;

}

and arrow_func = {

a_params : arrow_params;
a_return_type : type_opt;
a_tok : tok;
a_body : arrow_body;

}

and arrow_params =

| ASingleParam of parameter_binding
| AParams of parameter_binding comma_list paren

and arrow_body =

| AExpr of expr
| ABody of item list brace

and var_binding =

| VarClassic of variable_declaration
| VarPattern of variable_declaration_pattern

and variable_declaration = {

v_name : name;
v_init : init option;
v_type : type_opt;

}

and init = tok * expr

and var_kind =

| Var
| Const
| Let

and variable_declaration_pattern = {

vpat : pattern;
vpat_init : init option;
vpat_type : type_opt;

}

and pattern =

| PatObj of pattern comma_list brace
| PatArr of pattern comma_list bracket
| PatId of name * init option
| PatProp of property_name * tok * pattern
| PatDots of tok * pattern
| PatNest of pattern * init option

and class_decl = {

c_tok : tok;
c_name : name option;
c_type_params : type_parameter comma_list angle option;
c_extends : (tok * nominal_type) option;
c_body : class_element list brace;

}

and class_element =

| C_method of static_opt * func_decl
| C_field of field_decl * sc
| C_extrasemicolon of sc

and static_opt = tok option

and field_decl = {

fld_static : static_opt;
fld_name : property_name;
fld_type : type_opt;
fld_init : init option;

}

and interface_decl = {

i_tok : tok;
i_name : name;
i_type_params : type_parameter comma_list angle option;
i_type : type_;

}

and item =

| St of stmt
| FunDecl of func_decl
| ClassDecl of class_decl
| InterfaceDecl of interface_decl
| ItemTodo of tok

and import =

| ImportFrom of import_clause * (tok * module_path)
| ImportEffect of module_path

and import_clause = import_default option * name_import option

and name_import =

| ImportNamespace of tok * tok * name
| ImportNames of import_name comma_list brace
| ImportTypes of tok * import_name comma_list brace

and import_default = name

and import_name = name * (tok * name) option

and export =

| ExportDecl of item
| ExportDefaultDecl of tok * item
| ExportDefaultExpr of tok * expr * sc
| ExportNames of import_name comma_list brace * sc
| ReExportNamespace of tok * tok * module_path * sc
| ReExportNames of import_name comma_list brace * tok * module_path * sc

and module_item =

| It of item
| Import of tok * import * sc
| Export of tok * export

and program = module_item list

type any =

| Expr of expr
| Stmt of stmt
| Pattern of pattern
| Item of item
| Program of program

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

val unparen : ('a * 'b * 'c) -> 'b

val unbrace : ('a * 'b * 'c) -> 'b

val unbracket : ('a * 'b * 'c) -> 'b

val uncomma : ('a, 'b) Common.either list -> 'a list

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

val al_info : PI.token_mutable -> PI.token_mutable

val fakeInfoAttach : PI.info -> PI.token_mutable