package pfff

You can search for identifiers within the package.

in-package search v0.2.0

package pfff

pfff-lang_skip

Legend:
Library
Module
Module type
Parameter
Class
Class type

type tok = Parse_info.t

and info = tok

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 single_angle = tok * 'a * tok

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

and 'a comma_list_dots = ('a, tok, tok) Common.either3 list

type ident =

| Name of string wrap
| XhpName of xhp_tag wrap

and xhp_tag = string list

type dname =

| DName of string wrap

type qualified_ident = qualified_ident_element list

and qualified_ident_element =

| QI of ident
| QITok of tok

type name =

| XName of qualified_ident
| Self of tok
| Parent of tok
| LateStatic of tok

type hint_type =

| Hint of name * type_args option
| HintArray of tok
| HintQuestion of tok * hint_type
| HintTuple of hint_type comma_list paren
| HintCallback of (tok * hint_type comma_list_dots paren * (tok * tok option * hint_type) option) paren
| HintShape of tok * (string_const_expr * tok * hint_type) comma_list paren
| HintTypeConst of hint_type * tok * hint_type
| HintVariadic of tok * hint_type option

and type_args = hint_type comma_list single_angle

and type_params = type_param comma_list single_angle

and type_param =

| TParam of ident
| TParamConstraint of ident * tok * class_name

and class_name = hint_type

and ptype =

| BoolTy
| IntTy
| DoubleTy
| StringTy
| ArrayTy
| ObjectTy

and expr =

| Id of name
| IdVar of dname * Scope_php.phpscope ref
| This of tok
| Call of expr * argument comma_list paren
| ObjGet of expr * tok * expr
| ClassGet of class_name_reference * tok * expr
| ArrayGet of expr * expr option bracket
| HashGet of expr * expr brace
| BraceIdent of expr brace
| Deref of tok * expr
| Sc of scalar
| Binary of expr * binaryOp wrap * expr
| Unary of unaryOp wrap * expr
| Assign of lvalue * tok * expr
| AssignOp of lvalue * assignOp wrap * expr
| Postfix of rw_variable * fixOp wrap
| Infix of fixOp wrap * rw_variable
| CondExpr of expr * tok * expr option * tok * expr
| AssignList of tok * list_assign comma_list paren * tok * expr
| ArrayLong of tok * array_pair comma_list paren
| ArrayShort of array_pair comma_list bracket
| Collection of name * array_pair comma_list brace
| New of tok * class_name_reference * argument comma_list paren option
| Clone of tok * expr
| AssignRef of lvalue * tok * tok * lvalue
| AssignNew of lvalue * tok * tok * tok * class_name_reference * argument comma_list paren option
| Cast of castOp wrap * expr
| CastUnset of tok * expr
| InstanceOf of expr * tok * class_name_reference
| Eval of tok * expr paren
| Lambda of lambda_def
| ShortLambda of short_lambda_def
| Exit of tok * expr option paren option
| At of tok * expr
| Print of tok * expr
| BackQuote of tok * encaps list * tok
| Include of tok * expr
| IncludeOnce of tok * expr
| Require of tok * expr
| RequireOnce of tok * expr
| Empty of tok * lvalue paren
| Isset of tok * lvalue comma_list paren
| XhpHtml of xhp_html
| Yield of tok * array_pair
| YieldBreak of tok * tok
| Await of tok * expr
| SgrepExprDots of tok
| ParenExpr of expr paren

and scalar =

| C of constant
| Guil of tok * encaps list * tok
| HereDoc of tok * encaps list * tok

and constant =

| Int of string wrap
| Double of string wrap
| String of string wrap
| PreProcess of cpp_directive wrap
| XdebugClass of name * class_stmt list
| XdebugResource

and cpp_directive =

| Line
| File
| Dir
| ClassC
| TraitC
| MethodC
| FunctionC
| NamespaceC

and encaps =

| EncapsString of string wrap
| EncapsVar of lvalue
| EncapsCurly of tok * lvalue * tok
| EncapsDollarCurly of tok * lvalue * tok
| EncapsExpr of tok * expr * tok

and fixOp = Ast_generic.incr_decr

and binaryOp =

| Arith of arithOp
| Logical of logicalOp
| BinaryConcat
| Pipe
| CombinedComparison

and arithOp =

| Plus
| Minus
| Mul
| Div
| Mod
| DecLeft
| DecRight
| And
| Or
| Xor

and logicalOp =

| Inf
| Sup
| InfEq
| SupEq
| Eq
| NotEq
| Identical
| NotIdentical
| AndLog
| OrLog
| XorLog
| AndBool
| OrBool

and assignOp =

| AssignOpArith of arithOp
| AssignConcat

and unaryOp =

| UnPlus
| UnMinus
| UnBang
| UnTilde

and castOp = ptype

and list_assign =

| ListVar of lvalue
| ListList of tok * list_assign comma_list paren
| ListEmpty

and array_pair =

| ArrayExpr of expr
| ArrayRef of tok * lvalue
| ArrayArrowExpr of expr * tok * expr
| ArrayArrowRef of expr * tok * tok * lvalue

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 = xhp_attr_name * tok * xhp_attr_value

and xhp_attr_name = string wrap

and xhp_attr_value =

| XhpAttrString of tok * encaps list * tok
| XhpAttrExpr of expr brace
| SgrepXhpAttrValueMvar of string wrap

and xhp_body =

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

and argument =

| Arg of expr
| ArgRef of tok * w_variable
| ArgUnpack of tok * expr

and lvalue = expr

and class_name_reference = expr

and rw_variable = lvalue

and r_variable = lvalue

and w_variable = lvalue

and static_scalar = expr

and string_const_expr = expr

and stmt =

| ExprStmt of expr * tok
| EmptyStmt of tok
| Block of stmt_and_def list brace
| If of tok * expr paren * stmt * if_elseif list * if_else option
| IfColon of tok * expr paren * tok * stmt_and_def list * new_elseif list * new_else option * tok * tok
| While of tok * expr paren * colon_stmt
| Do of tok * stmt * tok * expr paren * tok
| For of tok * tok * for_expr * tok * for_expr * tok * for_expr * tok * colon_stmt
| Switch of tok * expr paren * switch_case_list
| Foreach of tok * tok * expr * tok option * tok * foreach_pattern * tok * colon_stmt
| Break of tok * expr option * tok
| Continue of tok * expr option * tok
| Return of tok * expr option * tok
| Throw of tok * expr * tok
| Try of tok * stmt_and_def list brace * catch list * finally list
| Echo of tok * expr comma_list * tok
| Globals of tok * global_var comma_list * tok
| StaticVars of tok * static_var comma_list * tok
| InlineHtml of string wrap
| Use of tok * use_filename * tok
| Unset of tok * lvalue comma_list paren * tok
| Declare of tok * declare comma_list paren * colon_stmt
| FuncDefNested of func_def
| ClassDefNested of class_def

and switch_case_list =

| CaseList of tok * tok option * case list * tok
| CaseColonList of tok * tok option * case list * tok * tok

and case =

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

and if_elseif = tok * expr paren * stmt

and if_else = tok * stmt

and for_expr = expr comma_list

and foreach_pattern =

| ForeachVar of foreach_variable
| ForeachArrow of foreach_pattern * tok * foreach_pattern
| ForeachList of tok * list_assign comma_list paren

and foreach_variable = is_ref * lvalue

and catch = tok * (class_name * dname) paren * stmt_and_def list brace

and finally = tok * stmt_and_def list brace

and use_filename =

| UseDirect of string wrap
| UseParen of string wrap paren

and declare = ident * static_scalar_affect

and colon_stmt =

| SingleStmt of stmt
| ColonStmt of tok * stmt_and_def list * tok * tok

and new_elseif = tok * expr paren * tok * stmt_and_def list

and new_else = tok * tok * stmt_and_def list

and stmt_and_def = stmt

and func_def = {

f_attrs : attributes option;
f_tok : tok;
f_type : function_type;
f_modifiers : modifier wrap list;
f_ref : is_ref;
f_name : ident;
f_tparams : type_params option;
f_params : parameter comma_list_dots paren;
f_return_type : (tok * tok option * hint_type) option;
f_body : stmt_and_def list brace;

}

and function_type =

| FunctionRegular
| FunctionLambda
| MethodRegular
| MethodAbstract

and parameter = {

p_attrs : attributes option;
p_modifier : modifier wrap option;
p_soft_type : tok option;
p_type : hint_type option;
p_ref : is_ref;
p_name : dname;
p_default : static_scalar_affect option;
p_variadic : tok option;

}

and is_ref = tok option

and lambda_def = lexical_vars option * func_def

and lexical_vars = tok * lexical_var comma_list paren

and lexical_var =

| LexicalVar of is_ref * dname

and short_lambda_def = {

sl_modifiers : modifier wrap list;
sl_params : short_lambda_params;
sl_tok : tok option;
sl_body : short_lambda_body;

}

and short_lambda_params =

| SLSingleParam of parameter
| SLParams of parameter comma_list_dots paren
| SLParamsOmitted

and short_lambda_body =

| SLExpr of expr
| SLBody of stmt_and_def list brace

and constant_def = {

cst_toks : tok * tok * tok;
cst_name : ident;
cst_type : hint_type option;
cst_val : static_scalar;

}

and class_def = {

c_attrs : attributes option;
c_type : class_type;
c_name : ident;
c_tparams : type_params option;
c_extends : extend option;
c_implements : interface option;
c_enum_type : enum_type option;
c_body : class_stmt list brace;

}

and class_type =

| ClassRegular of tok
| ClassAbstractFinal of tok * tok * tok
| ClassFinal of tok * tok
| ClassAbstract of tok * tok
| Interface of tok
| Trait of tok
| Enum of tok

and extend = tok * class_name

and interface = tok * class_name comma_list

and class_stmt =

| ClassConstants of tok option * tok * hint_type option * class_constant comma_list * tok
| ClassVariables of class_var_modifier * hint_type option * class_variable comma_list * tok
| Method of method_def
| XhpDecl of xhp_decl
| UseTrait of tok * class_name comma_list * (tok, trait_rule list brace) Common.either
| TraitConstraint of tok * trait_constraint_kind wrap * hint_type * tok
| ClassType of type_def

and class_constant = ident * static_scalar_affect option

and class_variable = dname * static_scalar_affect option

and class_var_modifier =

| NoModifiers of tok
| VModifiers of modifier wrap list

and method_def = func_def

and modifier =

| Public
| Private
| Protected
| Static
| Abstract
| Final
| Async

and xhp_decl =

| XhpAttributesDecl of tok * xhp_attribute_decl comma_list * tok
| XhpChildrenDecl of tok * xhp_children_decl * tok
| XhpCategoriesDecl of tok * xhp_category_decl comma_list * tok

and xhp_attribute_decl =

| XhpAttrInherit of xhp_tag wrap
| XhpAttrDecl of xhp_attribute_type * xhp_attr_name * xhp_value_affect option * tok option

and xhp_attribute_type =

| XhpAttrType of hint_type
| XhpAttrVar of tok
| XhpAttrEnum of tok * constant comma_list brace

and xhp_value_affect = tok * static_scalar

and xhp_children_decl =

| XhpChild of xhp_tag wrap
| XhpChildCategory of xhp_tag wrap
| XhpChildAny of tok
| XhpChildEmpty of tok
| XhpChildPcdata of tok
| XhpChildSequence of xhp_children_decl * tok * xhp_children_decl
| XhpChildAlternative of xhp_children_decl * tok * xhp_children_decl
| XhpChildMul of xhp_children_decl * tok
| XhpChildOption of xhp_children_decl * tok
| XhpChildPlus of xhp_children_decl * tok
| XhpChildParen of xhp_children_decl paren

and xhp_category_decl = xhp_tag wrap

and trait_rule =

| InsteadOf of name * tok * ident * tok * class_name comma_list * tok
| As of (ident, name * tok * ident) Common.either * tok * modifier wrap list * ident option * tok

and trait_constraint_kind =

| MustExtend
| MustImplement

and enum_type = {

e_tok : tok;
e_base : hint_type;
e_constraint : (tok * hint_type) option;

}

and type_def = {

t_tok : tok;
t_name : ident;
t_tparams : type_params option;
t_tconstraint : (tok * hint_type) option;
t_tokeq : tok;
t_kind : type_def_kind;
t_sc : tok;

}

and type_def_kind =

| Alias of hint_type
| Newtype of hint_type
| ClassConstType of hint_type option

and global_var =

| GlobalVar of dname
| GlobalDollar of tok * r_variable
| GlobalDollarExpr of tok * expr brace

and static_var = dname * static_scalar_affect option

and static_scalar_affect = tok * static_scalar

and namespace_use_rule =

| ImportNamespace of qualified_ident
| AliasNamespace of qualified_ident * tok * ident

and attribute =

| Attribute of string wrap
| AttributeWithArgs of string wrap * static_scalar comma_list paren

and attributes = attribute comma_list angle

and toplevel =

| StmtList of stmt list
| FuncDef of func_def
| ClassDef of class_def
| ConstantDef of constant_def
| TypeDef of type_def
| NamespaceDef of tok * qualified_ident * tok
| NamespaceBracketDef of tok * qualified_ident option * toplevel list brace
| NamespaceUse of tok * namespace_use_rule comma_list * tok
| NotParsedCorrectly of tok list
| FinalDef of tok

and program = toplevel list

type entity =

| FunctionE of func_def
| ClassE of class_def
| ConstantE of constant_def
| TypedefE of type_def
| StmtListE of stmt list
| MethodE of method_def
| ClassConstantE of class_constant
| ClassVariableE of class_variable * modifier list
| XhpAttrE of xhp_attribute_decl
| MiscE of tok list

type any =

| Expr of expr
| Stmt2 of stmt
| StmtAndDefs of stmt_and_def list
| Toplevel of toplevel
| Program of program
| Entity of entity
| Argument of argument
| Arguments of argument comma_list
| Parameter of parameter
| Parameters of parameter comma_list_dots paren
| Body of stmt_and_def list brace
| ClassStmt of class_stmt
| ClassConstant2 of class_constant
| ClassVariable of class_variable
| ListAssign of list_assign
| ColonStmt2 of colon_stmt
| Case2 of case
| XhpAttribute of xhp_attribute
| XhpAttrValue of xhp_attr_value
| XhpHtml2 of xhp_html
| XhpChildrenDecl2 of xhp_children_decl
| Info of tok
| InfoList of tok list
| Ident2 of ident
| Hint2 of hint_type

val noScope : unit -> Scope_code.t ref

val fakeInfo : 
  ?next_to:(Parse_info.token_location * int) option ->
  string ->
  Parse_info.token_mutable

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 uncomma_dots : ('a, 'b, 'b) Common.either3 list -> 'a list

val unarg : argument -> expr

val unargs : (argument, 'a) Common.either list -> expr list * w_variable list

val unmodifiers : class_var_modifier -> modifier list

val map_paren : ('a -> 'b) -> ('c * 'a * 'd) -> 'c * 'b * 'd

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

val al_info : Parse_info.token_mutable -> Parse_info.token_mutable

val str_of_ident : ident -> string

val info_of_ident : ident -> tok

val str_of_dname : dname -> string

val info_of_dname : dname -> tok

val info_of_qualified_ident : qualified_ident_element list -> tok

val info_of_name : name -> tok

exception TodoNamespace of tok

val str_of_name : name -> string

val str_of_name_namespace : name -> string

val name_of_class_name : hint_type -> name

val str_of_class_name : hint_type -> string

val ident_of_class_name : hint_type -> ident