Source file ast_generic_v1_t.ml

(* Auto-generated from "ast_generic_v1.atd" *)
[@@@ocaml.warning "-27-32-33-35-39"]

type class_kind = [ `Class | `Interface | `Trait | `Object ]

type concat_string_kind = [
    `InterpolatedConcat
  | `SequenceConcat
  | `FString of string
  | `TaggedTemplateLiteral
]

type const_type = [ `Cbool | `Cint | `Cstr | `Cany ]

type container_operator = [ `Array | `List | `Set | `Dict | `Tuple ]

type function_kind = [
    `Function | `Method | `LambdaKind | `Arrow | `BlockCases
]

type incr_decr = [ `Incr | `Decr ]

type keyword_attribute = [
    `Static
  | `Volatile
  | `Extern
  | `Public
  | `Private
  | `Protected
  | `Abstract
  | `Final
  | `Override
  | `RecordClass
  | `AnnotationClass
  | `EnumClass
  | `SealedClass
  | `Var
  | `Let
  | `Mutable
  | `Const
  | `Optional
  | `NotNull
  | `Recursive
  | `MutuallyRecursive
  | `Generator
  | `Async
  | `Inline
  | `Ctor
  | `Dtor
  | `Getter
  | `Setter
  | `Unsafe
  | `DefaultImpl
  | `Lazy
  | `Throws
  | `Rethrows
  | `OtherKeyword of string
]

type operator = [
    `Plus | `Minus | `Mult | `Div | `Mod | `Pow | `FloorDiv | `MatMult | `LSL
  | `LSR | `ASR | `BitOr | `BitXor | `BitAnd | `BitNot | `BitClear | `And
  | `Or | `Xor | `Not | `Eq | `NotEq | `PhysEq | `NotPhysEq | `Lt | `LtE
  | `Gt | `GtE | `Cmp | `Concat | `Append | `RegexpMatch | `NotMatch | `Range
  | `RangeInclusive | `NotNullPostfix | `Length | `Elvis | `Nullish | `In
  | `NotIn | `Is | `NotIs | `Background | `Pipe
]

type prefix_postfix = [ `Prefix | `Postfix ]

type sid = int

type special = [
    `This
  | `Super
  | `Self
  | `Parent
  | `Eval
  | `Typeof
  | `Instanceof
  | `Sizeof
  | `Defined
  | `ConcatString of concat_string_kind
  | `EncodedString of string
  | `InterpolatedElement
  | `Spread
  | `HashSplat
  | `ForOf
  | `Op of operator
  | `IncrDecr of (incr_decr * prefix_postfix)
  | `Require
  | `OtherSpecial of string
]

type token_location = {
  str: string;
  charpos: int;
  line: int;
  column: int;
  filename: string
}

type token = [ `OriginTok of token_location | `FakeTok of string ]

type tok = token

type 'a bracket = (tok * 'a * tok)

type sc = tok

type variance = [ `Covariant | `Contravariant ]

type 'a wrap_ = ('a * tok)

type ident = string wrap_

type dotted_ident = ident list

type label = ident

type literal = [
    `Bool of bool wrap_
  | `Int of int option wrap_
  | `Float of float option wrap_
  | `Char of string wrap_
  | `String of string wrap_
  | `Regexp of (string wrap_ bracket * string wrap_ option)
  | `Atom of (tok * string wrap_)
  | `Unit of tok
  | `Null of tok
  | `Undefined of tok
  | `Imag of string wrap_
  | `Ratio of string wrap_
]

type module_name = [
    `DottedName of dotted_ident
  | `FileName of string wrap_
]

type resolved_name_kind = [
    `Global
  | `Local
  | `Param
  | `ImportedEntity of dotted_ident
  | `ImportedModule of module_name
  | `OtherResolvedNameKind of string
]

type resolved_name = (resolved_name_kind * sid)

type todo_kind = string wrap_

type xml_kind = [
    `XmlClassic of (tok * ident * tok * tok)
  | `XmlSingleton of (tok * ident * tok)
  | `XmlFragment of (tok * tok)
]

type alias = (ident * id_info)

and any = [
    `E of expr
  | `S of stmt
  | `T of type_
  | `P of pattern
  | `At of attribute
  | `Fld of field
  | `Ar of argument
  | `Pa of parameter
  | `Ta of type_argument
  | `Tp of type_parameter
  | `Ce of catch_exn
  | `Cs of case
  | `ForOrIfComp of for_or_if_comp
  | `En of entity
  | `I of ident
  | `Modn of module_name
  | `Di of dotted_ident
  | `Lbli of label_ident
  | `Str of string wrap_
  | `Tk of tok
  | `TodoK of todo_kind
  | `Anys of (any list)
]

and argument = [
    `Arg of expr
  | `ArgKwd of (ident * expr)
  | `ArgKwdOptional of (ident * expr)
  | `ArgType of type_
  | `OtherArg of (todo_kind * any list)
]

and arguments = argument list bracket

and attribute = [
    `KeywordAttr of keyword_attribute wrap_
  | `NamedAttr of (tok * name * arguments)
  | `OtherAttribute of (todo_kind * any list)
]

and case = [
    `Case of (tok * pattern)
  | `Default of tok
  | `CaseEqualExpr of (tok * expr)
  | `OtherCase of (todo_kind * any list)
]

and case_and_body = [ `CasesAndBody of (case list * stmt) ]

and catch = (tok * catch_exn * stmt)

and catch_exn = [
    `CatchPattern of pattern
  | `CatchParam of parameter_classic
  | `OtherCatch of (todo_kind * any list)
]

and class_definition = {
  ckind: class_kind wrap_;
  cextends: class_parent list;
  cimplements: type_ list;
  cmixins: type_ list;
  cparams: parameters;
  cbody: field list bracket
}

and class_parent = (type_ * arguments option)

and comprehension = (expr * for_or_if_comp list)

and condition = [ `Cond of expr | `OtherCond of (todo_kind * any list) ]

and definition = (entity * definition_kind)

and definition_kind = [
    `FuncDef of function_definition
  | `VarDef of variable_definition
  | `ClassDef of class_definition
  | `EnumEntryDef of enum_entry_definition
  | `TypeDef of type_definition
  | `ModuleDef of module_definition
  | `MacroDef of macro_definition
  | `Signature of type_
  | `UseOuterDecl of tok
  | `OtherDef of (todo_kind * any list)
]

and directive = [
    `ImportFrom of (tok * module_name * (ident * alias option) list)
  | `ImportAs of (tok * module_name * alias option)
  | `ImportAll of (tok * module_name * tok)
  | `Package of (tok * dotted_ident)
  | `PackageEnd of tok
  | `Pragma of (ident * any list)
  | `OtherDirective of (todo_kind * any list)
]

and entity = {
  name: entity_name;
  attrs: attribute list;
  tparams: type_parameters
}

and entity_name = [
    `EN of name
  | `EDynamic of expr
  | `EPattern of pattern
  | `OtherEntity of (todo_kind * any list)
]

and enum_entry_definition = {
  ee_args: arguments option;
  ee_body: field list bracket option
}

and expr = [
    `L of literal
  | `Container of (container_operator * expr list bracket)
  | `Comprehension of (container_operator * comprehension bracket)
  | `Record of field list bracket
  | `Constructor of (name * expr list bracket)
  | `N of name
  | `IdSpecial of special wrap_
  | `Call of (expr * arguments)
  | `New of (tok * type_ * arguments)
  | `Xml of xml
  | `Assign of (expr * tok * expr)
  | `AssignOp of (expr * operator wrap_ * expr)
  | `LetPattern of (pattern * expr)
  | `DotAccess of (expr * tok * field_name)
  | `ArrayAccess of (expr * expr bracket)
  | `SliceAccess
      of (expr * (expr option * expr option * expr option) bracket)
  | `Lambda of function_definition
  | `AnonClass of class_definition
  | `Conditional of (expr * expr * expr)
  | `Yield of (tok * expr option * bool)
  | `Await of (tok * expr)
  | `Cast of (type_ * expr)
  | `Seq of expr list
  | `Ref of (tok * expr)
  | `DeRef of (tok * expr)
  | `Ellipsis of tok
  | `ParenExpr of expr bracket
  | `StmtExpr of stmt
  | `OtherExpr of (todo_kind * any list)
]

and field = [ `F of stmt ]

and field_name = [ `FN of name | `FDynamic of expr ]

and finally = (tok * stmt)

and for_each = (pattern * tok * expr)

and for_header = [
    `ForClassic of (for_var_or_expr list * expr option * expr option)
  | `ForEach of for_each
  | `MultiForEach of multi_for_each list
  | `ForIn of (for_var_or_expr list * expr list)
]

and for_or_if_comp = [
    `CompFor of (tok * pattern * tok * expr)
  | `CompIf of (tok * expr)
]

and for_var_or_expr = [
    `ForInitVar of (entity * variable_definition)
  | `ForInitExpr of expr
]

and function_body = [
    `FBStmt of stmt
  | `FBExpr of expr
  | `FBDecl of sc
  | `FBNothing
]

and function_definition = {
  fkind: function_kind wrap_;
  fparams: parameters;
  frettype: type_ option;
  fbody: function_body
}

and id_info = {
  id_resolved: resolved_name option;
  id_type: type_ option;
  id_svalue: svalue option
}

and item = stmt

and label_ident = [
    `LNone
  | `LId of label
  | `LInt of int wrap_
  | `LDynamic of expr
]

and macro_definition = { macroparams: ident list; macrobody: any list }

and module_definition = { mbody: module_definition_kind }

and module_definition_kind = [
    `ModuleAlias of dotted_ident
  | `ModuleStruct of (dotted_ident option * item list)
  | `OtherModule of (todo_kind * any list)
]

and multi_for_each = [ `FE of for_each | `FECond of (for_each * tok * expr) ]

and name = [ `Id of (ident * id_info) | `IdQualified of qualified_info ]

and or_type_element = [
    `OrConstructor of (ident * type_ list)
  | `OrEnum of (ident * expr option)
  | `OrUnion of (ident * type_)
  | `OtherOr of (todo_kind * any list)
]

and parameter = [
    `ParamClassic of parameter_classic
  | `ParamPattern of pattern
  | `ParamRest of (tok * parameter_classic)
  | `ParamHashSplat of (tok * parameter_classic)
  | `OtherParam of (todo_kind * any list)
]

and parameter_classic = {
  pname: ident option;
  ptype: type_ option;
  pdefault: expr option;
  pattrs: attribute list;
  pinfo: id_info
}

and parameters = parameter list

and pattern = [
    `PatLiteral of literal
  | `PatConstructor of (name * pattern list)
  | `PatRecord of (dotted_ident * pattern) list bracket
  | `PatId of (ident * id_info)
  | `PatTuple of pattern list bracket
  | `PatList of pattern list bracket
  | `PatKeyVal of (pattern * pattern)
  | `PatUnderscore of tok
  | `PatDisj of (pattern * pattern)
  | `PatTyped of (pattern * type_)
  | `PatWhen of (pattern * expr)
  | `PatAs of (pattern * (ident * id_info))
  | `PatType of type_
  | `OtherPat of (todo_kind * any list)
]

and qualified_info = {
  name_last: (ident * type_arguments option);
  name_middle: qualifier option;
  name_top: tok option;
  name_info: id_info
}

and qualifier = [
    `QDots of (ident * type_arguments option) list
  | `QExpr of (expr * tok)
]

and stmt = [
    `ExprStmt of (expr * sc)
  | `Block of stmt list bracket
  | `If of (tok * condition * stmt * stmt option)
  | `While of (tok * condition * stmt)
  | `Return of (tok * expr option * sc)
  | `DoWhile of (tok * stmt * expr)
  | `For of (tok * for_header * stmt)
  | `Switch of (tok * condition option * case_and_body list)
  | `Continue of (tok * label_ident * sc)
  | `Break of (tok * label_ident * sc)
  | `Label of (label * stmt)
  | `Goto of (tok * label)
  | `Throw of (tok * expr * sc)
  | `Try of (tok * stmt * catch list * finally option)
  | `WithUsingResource of (tok * stmt list * stmt)
  | `Assert of (tok * arguments * sc)
  | `DefStmt of definition
  | `DirectiveStmt of directive
  | `OtherStmt of (todo_kind * any list)
]

and svalue = [
    `Lit of literal
  | `Cst of const_type
  | `Sym of expr
  | `NotCst
]

and type_ = [
    `TyN of name
  | `TyApply of (type_ * type_arguments)
  | `TyFun of (parameter list * type_)
  | `TyArray of (expr option bracket * type_)
  | `TyTuple of type_ list bracket
  | `TyVar of ident
  | `TyAny of tok
  | `TyPointer of (tok * type_)
  | `TyRef of (tok * type_)
  | `TyQuestion of (type_ * tok)
  | `TyRest of (tok * type_)
  | `TyAnd of (type_ * tok * type_)
  | `TyOr of (type_ * tok * type_)
  | `TyRecordAnon of (class_kind wrap_ * field list bracket)
  | `TyExpr of expr
  | `OtherType of (todo_kind * any list)
]

and type_argument = [
    `TA of type_
  | `TAWildcard of (tok * (bool wrap_ * type_) option)
  | `TAExpr of expr
  | `OtherTypeArg of (todo_kind * any list)
]

and type_arguments = type_argument list bracket

and type_definition = { tbody: type_definition_kind }

and type_definition_kind = [
    `OrType of or_type_element list
  | `AndType of field list bracket
  | `AliasType of type_
  | `NewType of type_
  | `AbstractType of tok
  | `Exception of (ident * type_ list)
  | `OtherTypeKind of (todo_kind * any list)
]

and type_parameter = [
    `TP of type_parameter_classic
  | `OtherTypeParam of (todo_kind * any list)
]

and type_parameter_classic = {
  tp_id: ident;
  tp_attrs: attribute list;
  tp_bounds: type_ list;
  tp_default: type_ option;
  tp_variance: variance wrap_ option
}

and type_parameters = type_parameter list

and variable_definition = { vinit: expr option; vtype: type_ option }

and xml = {
  xml_kind: xml_kind;
  xml_attrs: xml_attribute list;
  xml_body: xml_body list
}

and xml_attr_value = expr

and xml_attribute = [
    `XmlAttr of (ident * tok * xml_attr_value)
  | `XmlAttrExpr of expr bracket
]

and xml_body = [
    `XmlText of string wrap_
  | `XmlExpr of expr option bracket
  | `XmlXml of xml
]

type program = item list