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.info

and 'a wrap = 'a * tok

type name = string wrap

type qualified_name = string

type resolved_name =

| Local
| Param
| Global of qualified_name
| NotResolved

type special =

| Null
| Undefined
| This
| Super
| Exports
| Module
| Define
| Arguments
| New
| NewTarget
| Eval
| Seq
| Void
| Typeof
| Instanceof
| In
| Delete
| Spread
| Yield
| YieldStar
| Await
| Encaps of name option
| Require
| UseStrict
| And
| Or
| Not
| Xor
| BitNot
| BitAnd
| BitOr
| BitXor
| Lsr
| Asr
| Lsl
| Equal
| PhysEqual
| Lower
| Greater
| Plus
| Minus
| Mul
| Div
| Mod
| Expo
| Incr of bool
| Decr of bool

type label = string wrap

type filename = string wrap

val default_entity : string

type property_name =

| PN of name
| PN_Computed of expr

and expr =

| Bool of bool wrap
| Num of string wrap
| String of string wrap
| Regexp of string wrap
| Id of name * resolved_name ref
| IdSpecial of special wrap
| Nop
| Assign of expr * expr
| Obj of obj_
| Class of class_ * name option
| ObjAccess of expr * property_name
| Arr of expr list
| ArrAccess of expr * expr
| Fun of fun_ * name option
| Apply of expr * expr list
| Conditional of expr * expr * expr

and stmt =

| VarDecl of var
| Block of stmt list
| ExprStmt of expr
| If of expr * stmt * stmt
| Do of stmt * expr
| While of expr * stmt
| For of for_header * stmt
| Switch of expr * case list
| Continue of label option
| Break of label option
| Return of expr
| Label of label * stmt
| Throw of expr
| Try of stmt * catch option * stmt option

and for_header =

| ForClassic of vars_or_expr * expr * expr
| ForIn of var_or_expr * expr

and vars_or_expr = (var list, expr) Common.either

and var_or_expr = (var, expr) Common.either

and case =

| Case of expr * stmt
| Default of stmt

and catch = name * stmt

and var = {

v_name : name;
v_kind : var_kind;
v_init : expr;
v_resolved : resolved_name ref;

}

and var_kind =

| Var
| Let
| Const

and fun_ = {

f_props : fun_prop list;
f_params : parameter list;
f_body : stmt;

}

and parameter = {

p_name : name;
p_default : expr option;
p_dots : bool;

}

and fun_prop =

| Generator
| Async
| Get
| Set

and obj_ = property list

and class_ = {

c_extends : expr option;
c_body : property list;

}

and property =

| Field of property_name * property_prop list * expr
| FieldSpread of expr

and property_prop =

| Static
| Public
| Private
| Protected

type module_directive =

| Import of name * name * filename
| Export of name
| ModuleAlias of name * filename
| ImportCss of filename
| ImportEffect of filename

type toplevel =

| V of var
| S of tok * stmt
| M of module_directive

type program = toplevel list

type any =

| Expr of expr
| Stmt of stmt
| Top of toplevel
| Program of program

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

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

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