pfff 0.39.5 · OCaml Package

type tok = Parse_info.t

type 'a wrap = 'a * tok

type 'a list1 = 'a list

type ident = string wrap

type qualified_ident = ident list

type typ =

| TBasic of string wrap
| TClass of class_type
| TArray of typ

and class_type = (ident * type_argument list) list1

and type_argument =

| TArgument of ref_type
| TQuestion of (bool * ref_type) option

and ref_type = typ

type type_parameter =

| TParam of ident * ref_type list

type modifier =

| Public
| Protected
| Private
| Abstract
| Static
| Final
| StrictFP
| Transient
| Volatile
| Synchronized
| Native
| Annotation of annotation

and annotation = name_or_class_type * annotation_element option

and modifiers = modifier wrap list

and annotation_element =

| AnnotArgValue of element_value
| AnnotArgPairInit of annotation_pair list
| EmptyAnnotArg

and element_value =

| AnnotExprInit of expr
| AnnotNestedAnnot of annotation
| AnnotArrayInit of element_value list

and annotation_pair = ident * element_value

and name_or_class_type = identifier_ list

and identifier_ =

| Id of ident
| Id_then_TypeArgs of ident * type_argument list
| TypeArgs_then_Id of type_argument list * identifier_

and name = (type_argument list * ident) list1

and expr =

| Name of name
| NameOrClassType of name_or_class_type
| Literal of literal
| ClassLiteral of typ
| NewClass of typ * arguments * decls option
| NewArray of typ * arguments * int * init option
| NewQualifiedClass of expr * ident * arguments * decls option
| Call of expr * arguments
| Dot of expr * ident
| ArrayAccess of expr * expr
| Unary of Ast_generic.arithmetic_operator wrap * expr
| Postfix of expr * Ast_generic.incr_decr wrap
| Prefix of Ast_generic.incr_decr wrap * expr
| Infix of expr * Ast_generic.arithmetic_operator wrap * expr
| Cast of typ * expr
| InstanceOf of expr * ref_type
| Conditional of expr * expr * expr
| Assign of expr * expr
| AssignOp of expr * Ast_generic.arithmetic_operator wrap * expr
| Ellipses of tok

and literal =

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

and arguments = expr list

and op = string

and stmt =

| Empty
| Block of stmts
| Expr of expr
| If of expr * stmt * stmt
| Switch of expr * (cases * stmts) list
| While of expr * stmt
| Do of stmt * expr
| For of for_control * stmt
| Break of ident option
| Continue of ident option
| Return of expr option
| Label of ident * stmt
| Sync of expr * stmt
| Try of stmt * catches * stmt option
| Throw of expr
| LocalVar of var_with_init
| LocalClass of class_decl
| Assert of expr * expr option

and stmts = stmt list

and case =

| Case of expr
| Default

and cases = case list

and for_control =

| ForClassic of for_init * expr list * expr list
| Foreach of var * expr

and for_init =

| ForInitVars of var_with_init list
| ForInitExprs of expr list

and catch = var * stmt

and catches = catch list

and var = {

v_name : ident;
v_mods : modifiers;
v_type : typ;

}

and vars = var list

and var_with_init = {

f_var : var;
f_init : init option;

}

and init =

| ExprInit of expr
| ArrayInit of init list

and method_decl = {

m_var : var;
m_formals : vars;
m_throws : qualified_ident list;
m_body : stmt;

}

and field = var_with_init

and enum_decl = {

en_name : ident;
en_mods : modifiers;
en_impls : ref_type list;
en_body : enum_constant list * decls;

}

and enum_constant =

| EnumSimple of ident
| EnumConstructor of ident * arguments
| EnumWithMethods of ident * method_decl list

and class_decl = {

cl_name : ident;
cl_kind : class_kind;
cl_tparams : type_parameter list;
cl_mods : modifiers;
cl_extends : typ option;
cl_impls : ref_type list;
cl_body : decls;

}

and class_kind =

| ClassRegular
| Interface

and decl =

| Class of class_decl
| Method of method_decl
| Field of field
| Enum of enum_decl
| Init of bool * stmt

and decls = decl list

type compilation_unit = {

package : qualified_ident option;
imports : (bool * qualified_ident) list;
decls : decls;

}

type program = compilation_unit

type any =

| AIdent of ident
| AExpr of expr
| AStmt of stmt
| ATyp of typ
| AVar of var
| AInit of init
| AMethod of method_decl
| AField of field
| AClass of class_decl
| ADecl of decl
| AProgram of program

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

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

val ast_todo : 'a list

val ast_todo2 : unit

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

val is_final : (modifier * 'a) list -> bool

val is_final_static : (modifier * 'a) list -> bool

val info_of_identifier_ : identifier_ -> tok

package pfff