package flow_parser

You can search for identifiers within the package.

in-package search v0.2.0

flow_parser
- Comment_attachment
  - comment_bounds_collector
  - trailing_comments_remover
- Comment_utils
  - inline_comments_stripper
- Declaration_parser
  - Declaration
    
    _
- Enum_common
- Enum_parser
  - Enum
    
    Parse
- Estree_translator
  - Config
  - Translate
    
    Config
    
    Impl
- Expression_parser
  - Expression
    
    _
- File_key
- Flow_ast
  - BigIntLiteral
  - BooleanLiteral
  - Class
    
    Body
    
    Decorator
    
    Extends
    
    Implements
    
    Interface
    
    Method
    
    PrivateField
    
    Property
  - Comment
  - ComputedKey
  - Expression
    
    ArgList
    
    Array
    
    AsConstExpression
    
    AsExpression
    
    Assignment
    
    Binary
    
    Call
    
    CallTypeArg
    
    Implicit
    
    CallTypeArgs
    
    Conditional
    
    Import
    
    Logical
    
    Member
    
    MetaProperty
    
    New
    
    Object
    
    Property
    
    SpreadProperty
    
    OptionalCall
    
    OptionalMember
    
    Sequence
    
    SpreadElement
    
    Super
    
    TSSatisfies
    
    TaggedTemplate
    
    TemplateLiteral
    
    Element
    
    This
    
    TypeCast
    
    Unary
    
    Update
    
    Yield
  - Function
    
    Param
    
    Params
    
    RestParam
    
    ReturnAnnot
    
    ThisParam
  - Identifier
  - JSX
    
    Attribute
    
    Closing
    
    ExpressionContainer
    
    Identifier
    
    MemberExpression
    
    NamespacedName
    
    Opening
    
    SpreadAttribute
    
    SpreadChild
    
    Text
  - ModuleRefLiteral
  - NumberLiteral
  - Pattern
    
    Array
    
    Element
    
    Identifier
    
    Object
    
    Property
    
    RestElement
  - PrivateName
  - Program
  - RegExpLiteral
  - Statement
    
    Block
    
    Break
    
    ComponentDeclaration
    
    Param
    
    Params
    
    RestParam
    
    Continue
    
    Debugger
    
    DeclareClass
    
    DeclareComponent
    
    DeclareExportDeclaration
    
    DeclareFunction
    
    DeclareModule
    
    DeclareModuleExports
    
    DeclareNamespace
    
    DeclareVariable
    
    DoWhile
    
    Empty
    
    EnumDeclaration
    
    BigIntBody
    
    BooleanBody
    
    DefaultedMember
    
    InitializedMember
    
    NumberBody
    
    StringBody
    
    SymbolBody
    
    ExportDefaultDeclaration
    
    ExportNamedDeclaration
    
    ExportBatchSpecifier
    
    ExportSpecifier
    
    Expression
    
    For
    
    ForIn
    
    ForOf
    
    If
    
    Alternate
    
    ImportDeclaration
    
    Interface
    
    Labeled
    
    OpaqueType
    
    Return
    
    Switch
    
    Case
    
    Throw
    
    Try
    
    CatchClause
    
    TypeAlias
    
    VariableDeclaration
    
    Declarator
    
    While
    
    With
  - StringLiteral
  - Syntax
  - Type
    
    Array
    
    Component
    
    Param
    
    Params
    
    RestParam
    
    Conditional
    
    Function
    
    Param
    
    Params
    
    RestParam
    
    ThisParam
    
    Generic
    
    Identifier
    
    IndexedAccess
    
    Infer
    
    Interface
    
    Intersection
    
    Keyof
    
    Nullable
    
    Object
    
    CallProperty
    
    Indexer
    
    InternalSlot
    
    MappedType
    
    Property
    
    SpreadProperty
    
    OptionalIndexedAccess
    
    Predicate
    
    ReadOnly
    
    Renders
    
    Tuple
    
    LabeledElement
    
    SpreadElement
    
    TypeArgs
    
    TypeGuard
    
    TypeParam
    
    TypeParams
    
    Typeof
    
    Target
    
    Union
  - Variable
  - Variance
- Flow_ast_mapper
  - mapper
- Flow_ast_utils
  - ExpressionSort
- Flow_lexer
- Js_id
- Js_id_unicode
- Jsdoc
- Jsx_parser
  - JSX
    
    _
- Lex_env
- Lex_result
- Loc
- Object_parser
  - Object
    
    _
- Offset_utils
- Parse_error
  - PP
- Parse_error_utils
- Parser_common
  - COVER
  - DECLARATION
  - EXPRESSION
  - JSX
  - OBJECT
  - PARSER
  - PATTERN
  - STATEMENT
  - TYPE
- Parser_env
  - Eat
  - Expect
  - Lex_mode
  - Peek
  - SSet
  - Try
- Parser_flow
  - Parse
- Pattern_cover
  - Cover
    
    _
- Pattern_parser
  - Pattern
    
    _
- RelativeLoc
- Statement_parser
  - Statement
    
    _
- Token
- Token_translator
  - Translate
    
    Impl
- Translator_intf
  - S
- Type_parser
  - Type
    
    _

Legend:
Library
Module
Module type
Parameter
Class
Class type

method program : ('loc, 'loc) Ast.Program.t -> ('loc, 'loc) Ast.Program.t

method statement : ('loc, 'loc) Ast.Statement.t -> ('loc, 'loc) Ast.Statement.t

method comment : 'loc Flow_ast.Comment.t -> 'loc Flow_ast.Comment.t

method syntax_opt : 'internal. ('loc, 'internal) Ast.Syntax.t option ->
  ('loc, 'internal) Ast.Syntax.t option

method syntax : 'internal. ('loc, 'internal) Ast.Syntax.t ->
  ('loc, 'internal) Ast.Syntax.t

method expression : ('loc, 'loc) Ast.Expression.t ->
  ('loc, 'loc) Ast.Expression.t

method array : 'loc ->
  ('loc, 'loc) Ast.Expression.Array.t ->
  ('loc, 'loc) Ast.Expression.Array.t

method array_element : ('loc, 'loc) Ast.Expression.Array.element ->
  ('loc, 'loc) Ast.Expression.Array.element

method arrow_function : 'loc ->
  ('loc, 'loc) Ast.Function.t ->
  ('loc, 'loc) Ast.Function.t

method as_const_expression : 'loc ->
  ('loc, 'loc) Ast.Expression.AsConstExpression.t ->
  ('loc, 'loc) Ast.Expression.AsConstExpression.t

method as_expression : 'loc ->
  ('loc, 'loc) Ast.Expression.AsExpression.t ->
  ('loc, 'loc) Ast.Expression.AsExpression.t

method assignment : 'loc ->
  ('loc, 'loc) Ast.Expression.Assignment.t ->
  ('loc, 'loc) Ast.Expression.Assignment.t

method binary : 'loc ->
  ('loc, 'loc) Ast.Expression.Binary.t ->
  ('loc, 'loc) Ast.Expression.Binary.t

method block : 'loc ->
  ('loc, 'loc) Ast.Statement.Block.t ->
  ('loc, 'loc) Ast.Statement.Block.t

method break : 'loc -> 'loc Ast.Statement.Break.t -> 'loc Ast.Statement.Break.t

method call : 'loc ->
  ('loc, 'loc) Ast.Expression.Call.t ->
  ('loc, 'loc) Ast.Expression.Call.t

method arg_list : ('loc, 'loc) Flow_ast.Expression.ArgList.t ->
  ('loc, 'loc) Flow_ast.Expression.ArgList.t

method optional_call : 'loc ->
  ('loc, 'loc) Ast.Expression.OptionalCall.t ->
  ('loc, 'loc) Ast.Expression.OptionalCall.t

method call_type_args : ('loc, 'loc) Flow_ast.Expression.CallTypeArgs.t ->
  ('loc, 'loc) Flow_ast.Expression.CallTypeArgs.t

method call_type_arg : ('loc, 'loc) Ast.Expression.CallTypeArg.t ->
  ('loc, 'loc) Ast.Expression.CallTypeArg.t

method catch_body : ('loc * ('loc, 'loc) Ast.Statement.Block.t) ->
  'loc * ('loc, 'loc) Ast.Statement.Block.t

method catch_clause : 'loc ->
  ('loc, 'loc) Ast.Statement.Try.CatchClause.t' ->
  ('loc, 'loc) Ast.Statement.Try.CatchClause.t'

method class_declaration : 'loc ->
  ('loc, 'loc) Ast.Class.t ->
  ('loc, 'loc) Ast.Class.t

method class_expression : 'loc ->
  ('loc, 'loc) Ast.Class.t ->
  ('loc, 'loc) Ast.Class.t

method class_ : 'loc -> ('loc, 'loc) Ast.Class.t -> ('loc, 'loc) Ast.Class.t

method class_extends : 'loc ->
  ('loc, 'loc) Ast.Class.Extends.t' ->
  ('loc, 'loc) Ast.Class.Extends.t'

method class_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method class_body : ('loc, 'loc) Flow_ast.Class.Body.t ->
  ('loc, 'loc) Flow_ast.Class.Body.t

method class_decorator : ('loc, 'loc) Ast.Class.Decorator.t ->
  ('loc, 'loc) Ast.Class.Decorator.t

method class_element : ('loc, 'loc) Ast.Class.Body.element ->
  ('loc, 'loc) Ast.Class.Body.element

method class_implements : ('loc, 'loc) Ast.Class.Implements.t ->
  ('loc, 'loc) Ast.Class.Implements.t

method class_implements_interface : ('loc, 'loc)
                                      Ast.Class.Implements.Interface.t ->
  ('loc, 'loc) Ast.Class.Implements.Interface.t

method class_method : 'loc ->
  ('loc, 'loc) Ast.Class.Method.t' ->
  ('loc, 'loc) Ast.Class.Method.t'

method class_property : 'loc ->
  ('loc, 'loc) Ast.Class.Property.t' ->
  ('loc, 'loc) Ast.Class.Property.t'

method class_property_value : ('loc, 'loc) Ast.Class.Property.value ->
  ('loc, 'loc) Ast.Class.Property.value

method class_private_field : 'loc ->
  ('loc, 'loc) Ast.Class.PrivateField.t' ->
  ('loc, 'loc) Ast.Class.PrivateField.t'

method default_opt : ('loc, 'loc) Ast.Expression.t option ->
  ('loc, 'loc) Flow_ast.Expression.t option

method component_declaration : 'loc ->
  ('loc, 'loc) Ast.Statement.ComponentDeclaration.t ->
  ('loc, 'loc) Ast.Statement.ComponentDeclaration.t

method component_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method component_params : ('loc, 'loc)
                            Ast.Statement.ComponentDeclaration.Params.t ->
  ('loc, 'loc) Ast.Statement.ComponentDeclaration.Params.t

method component_param : ('loc, 'loc)
                           Flow_ast.Statement.ComponentDeclaration.Param.t ->
  ('loc, 'loc) Flow_ast.Statement.ComponentDeclaration.Param.t

method component_param_name : ('loc, 'loc)
                                Ast.Statement.ComponentDeclaration.Param.param_name ->
  ('loc, 'loc) Ast.Statement.ComponentDeclaration.Param.param_name

method component_param_pattern : ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method component_rest_param : ('loc, 'loc)
                                Flow_ast.Statement.ComponentDeclaration.RestParam.t ->
  ('loc, 'loc) Flow_ast.Statement.ComponentDeclaration.RestParam.t

method component_body : ('loc * ('loc, 'loc) Ast.Statement.Block.t) ->
  'loc * ('loc, 'loc) Ast.Statement.Block.t

method conditional : 'loc ->
  ('loc, 'loc) Ast.Expression.Conditional.t ->
  ('loc, 'loc) Ast.Expression.Conditional.t

method continue : 'loc ->
  'loc Ast.Statement.Continue.t ->
  'loc Ast.Statement.Continue.t

method debugger : 'loc ->
  'loc Ast.Statement.Debugger.t ->
  'loc Ast.Statement.Debugger.t

method declare_class : 'loc ->
  ('loc, 'loc) Ast.Statement.DeclareClass.t ->
  ('loc, 'loc) Ast.Statement.DeclareClass.t

method declare_component : 'loc ->
  ('loc, 'loc) Ast.Statement.DeclareComponent.t ->
  ('loc, 'loc) Ast.Statement.DeclareComponent.t

method component_type : 'loc ->
  ('loc, 'loc) Ast.Type.Component.t ->
  ('loc, 'loc) Ast.Type.Component.t

method component_type_params : ('loc, 'loc) Flow_ast.Type.Component.Params.t ->
  ('loc, 'loc) Flow_ast.Type.Component.Params.t

method component_type_param : ('loc, 'loc) Flow_ast.Type.Component.Param.t ->
  ('loc, 'loc) Flow_ast.Type.Component.Param.t

method component_type_rest_param : ('loc, 'loc)
                                     Flow_ast.Type.Component.RestParam.t ->
  ('loc, 'loc) Flow_ast.Type.Component.RestParam.t

method declare_enum : 'loc ->
  ('loc, 'loc) Ast.Statement.EnumDeclaration.t ->
  ('loc, 'loc) Ast.Statement.EnumDeclaration.t

method declare_export_declaration : 'loc ->
  ('loc, 'loc) Ast.Statement.DeclareExportDeclaration.t ->
  ('loc, 'loc) Ast.Statement.DeclareExportDeclaration.t

method declare_export_declaration_decl : ('loc, 'loc)
                                           Ast.Statement.DeclareExportDeclaration.declaration ->
  ('loc, 'loc) Ast.Statement.DeclareExportDeclaration.declaration

method declare_function : 'loc ->
  ('loc, 'loc) Ast.Statement.DeclareFunction.t ->
  ('loc, 'loc) Ast.Statement.DeclareFunction.t

method declare_interface : 'loc ->
  ('loc, 'loc) Ast.Statement.Interface.t ->
  ('loc, 'loc) Ast.Statement.Interface.t

method declare_module : 'loc ->
  ('loc, 'loc) Ast.Statement.DeclareModule.t ->
  ('loc, 'loc) Ast.Statement.DeclareModule.t

method declare_module_exports : 'loc ->
  ('loc, 'loc) Ast.Statement.DeclareModuleExports.t ->
  ('loc, 'loc) Ast.Statement.DeclareModuleExports.t

method declare_namespace : 'loc ->
  ('loc, 'loc) Ast.Statement.DeclareNamespace.t ->
  ('loc, 'loc) Ast.Statement.DeclareNamespace.t

method declare_type_alias : 'loc ->
  ('loc, 'loc) Ast.Statement.TypeAlias.t ->
  ('loc, 'loc) Ast.Statement.TypeAlias.t

method declare_variable : 'loc ->
  ('loc, 'loc) Ast.Statement.DeclareVariable.t ->
  ('loc, 'loc) Ast.Statement.DeclareVariable.t

method do_while : 'loc ->
  ('loc, 'loc) Ast.Statement.DoWhile.t ->
  ('loc, 'loc) Ast.Statement.DoWhile.t

method empty : 'loc -> 'loc Ast.Statement.Empty.t -> 'loc Ast.Statement.Empty.t

method enum_declaration : 'loc ->
  ('loc, 'loc) Ast.Statement.EnumDeclaration.t ->
  ('loc, 'loc) Ast.Statement.EnumDeclaration.t

method enum_body : 'loc Ast.Statement.EnumDeclaration.body ->
  'loc Ast.Statement.EnumDeclaration.body

method enum_boolean_body : 'loc Ast.Statement.EnumDeclaration.BooleanBody.t ->
  'loc Ast.Statement.EnumDeclaration.BooleanBody.t

method enum_number_body : 'loc Ast.Statement.EnumDeclaration.NumberBody.t ->
  'loc Ast.Statement.EnumDeclaration.NumberBody.t

method enum_string_body : 'loc Ast.Statement.EnumDeclaration.StringBody.t ->
  'loc Ast.Statement.EnumDeclaration.StringBody.t

method enum_symbol_body : 'loc Ast.Statement.EnumDeclaration.SymbolBody.t ->
  'loc Ast.Statement.EnumDeclaration.SymbolBody.t

method enum_bigint_body : 'loc Ast.Statement.EnumDeclaration.BigIntBody.t ->
  'loc Ast.Statement.EnumDeclaration.BigIntBody.t

method enum_defaulted_member : 'loc
                                 Flow_ast.Statement.EnumDeclaration.DefaultedMember.t ->
  'loc Flow_ast.Statement.EnumDeclaration.DefaultedMember.t

method enum_boolean_member : ('loc Ast.BooleanLiteral.t, 'loc)
                               Flow_ast.Statement.EnumDeclaration.InitializedMember.t ->
  ('loc Ast.BooleanLiteral.t, 'loc)
    Flow_ast.Statement.EnumDeclaration.InitializedMember.t

method enum_number_member : ('loc Ast.NumberLiteral.t, 'loc)
                              Flow_ast.Statement.EnumDeclaration.InitializedMember.t ->
  ('loc Ast.NumberLiteral.t, 'loc)
    Flow_ast.Statement.EnumDeclaration.InitializedMember.t

method enum_string_member : ('loc Ast.StringLiteral.t, 'loc)
                              Flow_ast.Statement.EnumDeclaration.InitializedMember.t ->
  ('loc Ast.StringLiteral.t, 'loc)
    Flow_ast.Statement.EnumDeclaration.InitializedMember.t

method enum_bigint_member : ('loc Ast.BigIntLiteral.t, 'loc)
                              Flow_ast.Statement.EnumDeclaration.InitializedMember.t ->
  ('loc Ast.BigIntLiteral.t, 'loc)
    Flow_ast.Statement.EnumDeclaration.InitializedMember.t

method enum_member_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method export_default_declaration : 'loc ->
  ('loc, 'loc) Ast.Statement.ExportDefaultDeclaration.t ->
  ('loc, 'loc) Ast.Statement.ExportDefaultDeclaration.t

method export_default_declaration_decl : ('loc, 'loc)
                                           Ast.Statement.ExportDefaultDeclaration.declaration ->
  ('loc, 'loc) Ast.Statement.ExportDefaultDeclaration.declaration

method export_named_declaration : 'loc ->
  ('loc, 'loc) Ast.Statement.ExportNamedDeclaration.t ->
  ('loc, 'loc) Ast.Statement.ExportNamedDeclaration.t

method export_named_declaration_specifier : ('loc, 'loc)
                                              Ast.Statement.ExportNamedDeclaration.ExportSpecifier.t ->
  ('loc, 'loc) Ast.Statement.ExportNamedDeclaration.ExportSpecifier.t

method export_batch_specifier : ('loc, 'loc)
                                  Ast.Statement.ExportNamedDeclaration.ExportBatchSpecifier.t ->
  ('loc, 'loc) Ast.Statement.ExportNamedDeclaration.ExportBatchSpecifier.t

method export_named_specifier : ('loc, 'loc)
                                  Ast.Statement.ExportNamedDeclaration.specifier ->
  ('loc, 'loc) Ast.Statement.ExportNamedDeclaration.specifier

method export_source : 'loc ->
  'loc Ast.StringLiteral.t ->
  'loc Ast.StringLiteral.t

method expression_statement : 'loc ->
  ('loc, 'loc) Ast.Statement.Expression.t ->
  ('loc, 'loc) Ast.Statement.Expression.t

method expression_or_spread : ('loc, 'loc) Ast.Expression.expression_or_spread ->
  ('loc, 'loc) Ast.Expression.expression_or_spread

method for_in_statement : 'loc ->
  ('loc, 'loc) Ast.Statement.ForIn.t ->
  ('loc, 'loc) Ast.Statement.ForIn.t

method for_in_statement_lhs : ('loc, 'loc) Ast.Statement.ForIn.left ->
  ('loc, 'loc) Ast.Statement.ForIn.left

method for_in_left_declaration : ('loc
                                  * ('loc, 'loc)
                                      Ast.Statement.VariableDeclaration.t) ->
  'loc * ('loc, 'loc) Ast.Statement.VariableDeclaration.t

method for_of_statement : 'loc ->
  ('loc, 'loc) Ast.Statement.ForOf.t ->
  ('loc, 'loc) Ast.Statement.ForOf.t

method for_of_statement_lhs : ('loc, 'loc) Ast.Statement.ForOf.left ->
  ('loc, 'loc) Ast.Statement.ForOf.left

method for_of_left_declaration : ('loc
                                  * ('loc, 'loc)
                                      Ast.Statement.VariableDeclaration.t) ->
  'loc * ('loc, 'loc) Ast.Statement.VariableDeclaration.t

method for_statement : 'loc ->
  ('loc, 'loc) Ast.Statement.For.t ->
  ('loc, 'loc) Ast.Statement.For.t

method for_statement_init : ('loc, 'loc) Ast.Statement.For.init ->
  ('loc, 'loc) Ast.Statement.For.init

method for_init_declaration : ('loc
                               * ('loc, 'loc)
                                   Ast.Statement.VariableDeclaration.t) ->
  'loc * ('loc, 'loc) Ast.Statement.VariableDeclaration.t

method function_param_type : ('loc, 'loc) Ast.Type.Function.Param.t ->
  ('loc, 'loc) Ast.Type.Function.Param.t

method function_rest_param_type : ('loc, 'loc) Ast.Type.Function.RestParam.t ->
  ('loc, 'loc) Ast.Type.Function.RestParam.t

method function_this_param_type : ('loc, 'loc) Ast.Type.Function.ThisParam.t ->
  ('loc, 'loc) Ast.Type.Function.ThisParam.t

method function_type_return_annotation : ('loc, 'loc)
                                           Ast.Type.Function.return_annotation ->
  ('loc, 'loc) Ast.Type.Function.return_annotation

method function_type : 'loc ->
  ('loc, 'loc) Ast.Type.Function.t ->
  ('loc, 'loc) Ast.Type.Function.t

method label_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method object_property_value_type : ('loc, 'loc) Ast.Type.Object.Property.value ->
  ('loc, 'loc) Ast.Type.Object.Property.value

method object_type_property_getter : ('loc * ('loc, 'loc) Ast.Type.Function.t) ->
  'loc * ('loc, 'loc) Ast.Type.Function.t

method object_type_property_setter : ('loc * ('loc, 'loc) Ast.Type.Function.t) ->
  'loc * ('loc, 'loc) Ast.Type.Function.t

method object_property_type : ('loc, 'loc) Ast.Type.Object.Property.t ->
  ('loc, 'loc) Ast.Type.Object.Property.t

method object_spread_property_type : ('loc, 'loc)
                                       Ast.Type.Object.SpreadProperty.t ->
  ('loc, 'loc) Ast.Type.Object.SpreadProperty.t

method object_indexer_property_type : ('loc, 'loc) Ast.Type.Object.Indexer.t ->
  ('loc, 'loc) Ast.Type.Object.Indexer.t

method object_internal_slot_property_type : ('loc, 'loc)
                                              Ast.Type.Object.InternalSlot.t ->
  ('loc, 'loc) Ast.Type.Object.InternalSlot.t

method object_call_property_type : ('loc, 'loc) Ast.Type.Object.CallProperty.t ->
  ('loc, 'loc) Ast.Type.Object.CallProperty.t

method object_mapped_type_property : ('loc, 'loc) Ast.Type.Object.MappedType.t ->
  ('loc, 'loc) Ast.Type.Object.MappedType.t

method object_type : 'loc ->
  ('loc, 'loc) Ast.Type.Object.t ->
  ('loc, 'loc) Ast.Type.Object.t

method object_type_property : ('loc, 'loc) Ast.Type.Object.property ->
  ('loc, 'loc) Ast.Type.Object.property

method interface_type : 'loc ->
  ('loc, 'loc) Ast.Type.Interface.t ->
  ('loc, 'loc) Ast.Type.Interface.t

method generic_identifier_type : ('loc, 'loc) Ast.Type.Generic.Identifier.t ->
  ('loc, 'loc) Ast.Type.Generic.Identifier.t

method generic_qualified_identifier_type : ('loc, 'loc)
                                             Ast.Type.Generic.Identifier.qualified ->
  ('loc, 'loc) Ast.Type.Generic.Identifier.qualified

method member_type_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method variance : 'loc Ast.Variance.t -> 'loc Ast.Variance.t

method variance_opt : 'loc Flow_ast.Variance.t option ->
  'loc Flow_ast.Variance.t option

method type_args : ('loc, 'loc) Flow_ast.Type.TypeArgs.t ->
  ('loc, 'loc) Flow_ast.Type.TypeArgs.t

method type_params : ('loc, 'loc) Flow_ast.Type.TypeParams.t ->
  ('loc, 'loc) Flow_ast.Type.TypeParams.t

method type_param : ('loc, 'loc) Flow_ast.Type.TypeParam.t ->
  ('loc, 'loc) Flow_ast.Type.TypeParam.t

method generic_type : 'loc ->
  ('loc, 'loc) Ast.Type.Generic.t ->
  ('loc, 'loc) Ast.Type.Generic.t

method indexed_access_type : 'loc ->
  ('loc, 'loc) Ast.Type.IndexedAccess.t ->
  ('loc, 'loc) Ast.Type.IndexedAccess.t

method optional_indexed_access_type : 'loc ->
  ('loc, 'loc) Ast.Type.OptionalIndexedAccess.t ->
  ('loc, 'loc) Ast.Type.OptionalIndexedAccess.t

method string_literal : 'loc ->
  'loc Ast.StringLiteral.t ->
  'loc Ast.StringLiteral.t

method number_literal : 'loc ->
  'loc Ast.NumberLiteral.t ->
  'loc Ast.NumberLiteral.t

method bigint_literal : 'loc ->
  'loc Ast.BigIntLiteral.t ->
  'loc Ast.BigIntLiteral.t

method boolean_literal : 'loc ->
  'loc Ast.BooleanLiteral.t ->
  'loc Ast.BooleanLiteral.t

method null_literal : 'loc ->
  ('loc, unit) Ast.Syntax.t option ->
  ('loc, unit) Ast.Syntax.t option

method regexp_literal : 'loc ->
  'loc Ast.RegExpLiteral.t ->
  'loc Ast.RegExpLiteral.t

method module_ref_literal : 'loc ->
  ('loc, 'loc) Ast.ModuleRefLiteral.t ->
  ('loc, 'loc) Ast.ModuleRefLiteral.t

method nullable_type : ('loc, 'loc) Ast.Type.Nullable.t ->
  ('loc, 'loc) Ast.Type.Nullable.t

method conditional_type : ('loc, 'loc) Ast.Type.Conditional.t ->
  ('loc, 'loc) Ast.Type.Conditional.t

method infer_type : ('loc, 'loc) Ast.Type.Infer.t ->
  ('loc, 'loc) Ast.Type.Infer.t

method typeof_type : ('loc, 'loc) Ast.Type.Typeof.t ->
  ('loc, 'loc) Ast.Type.Typeof.t

method typeof_expression : ('loc, 'loc) Ast.Type.Typeof.Target.t ->
  ('loc, 'loc) Ast.Type.Typeof.Target.t

method typeof_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method typeof_member_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method typeof_qualified_identifier : ('loc, 'loc)
                                       Ast.Type.Typeof.Target.qualified ->
  ('loc, 'loc) Ast.Type.Typeof.Target.qualified

method keyof_type : ('loc, 'loc) Ast.Type.Keyof.t ->
  ('loc, 'loc) Ast.Type.Keyof.t

method render_type : ('loc, 'loc) Ast.Type.Renders.t ->
  ('loc, 'loc) Ast.Type.Renders.t

method readonly_type : ('loc, 'loc) Ast.Type.ReadOnly.t ->
  ('loc, 'loc) Ast.Type.ReadOnly.t

method tuple_type : ('loc, 'loc) Ast.Type.Tuple.t ->
  ('loc, 'loc) Ast.Type.Tuple.t

method tuple_element : ('loc, 'loc) Ast.Type.Tuple.element ->
  ('loc, 'loc) Ast.Type.Tuple.element

method tuple_labeled_element : ('loc, 'loc) Ast.Type.Tuple.LabeledElement.t ->
  ('loc, 'loc) Ast.Type.Tuple.LabeledElement.t

method tuple_spread_element : ('loc, 'loc) Ast.Type.Tuple.SpreadElement.t ->
  ('loc, 'loc) Ast.Type.Tuple.SpreadElement.t

method array_type : ('loc, 'loc) Ast.Type.Array.t ->
  ('loc, 'loc) Ast.Type.Array.t

method union_type : 'loc ->
  ('loc, 'loc) Ast.Type.Union.t ->
  ('loc, 'loc) Ast.Type.Union.t

method intersection_type : 'loc ->
  ('loc, 'loc) Ast.Type.Intersection.t ->
  ('loc, 'loc) Ast.Type.Intersection.t

method type_ : ('loc, 'loc) Flow_ast.Type.t -> ('loc, 'loc) Flow_ast.Type.t

method type_annotation : ('loc, 'loc) Flow_ast.Type.annotation ->
  ('loc, 'loc) Flow_ast.Type.annotation

method type_annotation_hint : ('loc, 'loc) Ast.Type.annotation_or_hint ->
  ('loc, 'loc) Ast.Type.annotation_or_hint

method component_renders_annotation : ('loc, 'loc)
                                        Ast.Type.component_renders_annotation ->
  ('loc, 'loc) Ast.Type.component_renders_annotation

method function_declaration : 'loc ->
  ('loc, 'loc) Ast.Function.t ->
  ('loc, 'loc) Ast.Function.t

method function_expression : 'loc ->
  ('loc, 'loc) Ast.Function.t ->
  ('loc, 'loc) Ast.Function.t

method function_expression_or_method : 'loc ->
  ('loc, 'loc) Ast.Function.t ->
  ('loc, 'loc) Ast.Function.t

previously, we conflated function_expression and class_method. callers should be updated to override those individually.

deprecated Use either function_expression or class_method

method function_ : 'loc ->
  ('loc, 'loc) Ast.Function.t ->
  ('loc, 'loc) Ast.Function.t

method function_params : ('loc, 'loc) Ast.Function.Params.t ->
  ('loc, 'loc) Ast.Function.Params.t

method function_this_param : ('loc, 'loc) Flow_ast.Function.ThisParam.t ->
  ('loc, 'loc) Flow_ast.Function.ThisParam.t

method function_param : ('loc, 'loc) Flow_ast.Function.Param.t ->
  ('loc, 'loc) Flow_ast.Function.Param.t

method function_return_annotation : ('loc, 'loc) Ast.Function.ReturnAnnot.t ->
  ('loc, 'loc) Ast.Function.ReturnAnnot.t

method function_body_any : ('loc, 'loc) Ast.Function.body ->
  ('loc, 'loc) Ast.Function.body

method function_body : ('loc * ('loc, 'loc) Ast.Statement.Block.t) ->
  'loc * ('loc, 'loc) Ast.Statement.Block.t

method body_expression : ('loc, 'loc) Flow_ast.Expression.t ->
  ('loc, 'loc) Flow_ast.Expression.t

method function_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method type_identifier : ('loc, 'loc) Ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method type_identifier_reference : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method binding_type_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method interface : 'loc ->
  ('loc, 'loc) Ast.Statement.Interface.t ->
  ('loc, 'loc) Ast.Statement.Interface.t

method interface_declaration : 'loc ->
  ('loc, 'loc) Ast.Statement.Interface.t ->
  ('loc, 'loc) Ast.Statement.Interface.t

method private_name : 'loc Flow_ast.PrivateName.t ->
  'loc Flow_ast.PrivateName.t

method computed_key : ('loc, 'loc) Ast.ComputedKey.t ->
  ('loc, 'loc) Ast.ComputedKey.t

method import : 'loc ->
  ('loc, 'loc) Ast.Expression.Import.t ->
  ('loc, 'loc) Ast.Expression.Import.t

method if_consequent_statement : has_else:bool ->
  ('loc, 'loc) Ast.Statement.t ->
  ('loc, 'loc) Ast.Statement.t

method if_alternate_statement : 'loc ->
  ('loc, 'loc) Ast.Statement.If.Alternate.t' ->
  ('loc, 'loc) Ast.Statement.If.Alternate.t'

method if_statement : 'loc ->
  ('loc, 'loc) Ast.Statement.If.t ->
  ('loc, 'loc) Ast.Statement.If.t

method import_declaration : 'loc ->
  ('loc, 'loc) Ast.Statement.ImportDeclaration.t ->
  ('loc, 'loc) Ast.Statement.ImportDeclaration.t

method import_source : 'loc ->
  'loc Ast.StringLiteral.t ->
  'loc Ast.StringLiteral.t

method import_specifier : import_kind:
                            Ast.Statement.ImportDeclaration.import_kind ->
  ('loc, 'loc) Ast.Statement.ImportDeclaration.specifier ->
  ('loc, 'loc) Ast.Statement.ImportDeclaration.specifier

method remote_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method import_named_specifier : import_kind:
                                  Ast.Statement.ImportDeclaration.import_kind ->
  ('loc, 'loc) Ast.Statement.ImportDeclaration.named_specifier ->
  ('loc, 'loc) Ast.Statement.ImportDeclaration.named_specifier

method import_default_specifier : import_kind:
                                    Ast.Statement.ImportDeclaration.import_kind ->
  ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method import_namespace_specifier : import_kind:
                                      Ast.Statement.ImportDeclaration.import_kind ->
  'loc ->
  ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method jsx_element : 'loc ->
  ('loc, 'loc) Ast.JSX.element ->
  ('loc, 'loc) Ast.JSX.element

method jsx_fragment : 'loc ->
  ('loc, 'loc) Ast.JSX.fragment ->
  ('loc, 'loc) Ast.JSX.fragment

method jsx_opening_element : ('loc, 'loc) Ast.JSX.Opening.t ->
  ('loc, 'loc) Ast.JSX.Opening.t

method jsx_closing_element : ('loc, 'loc) Ast.JSX.Closing.t ->
  ('loc, 'loc) Ast.JSX.Closing.t

method jsx_opening_attribute : ('loc, 'loc) Ast.JSX.Opening.attribute ->
  ('loc, 'loc) Ast.JSX.Opening.attribute

method jsx_spread_attribute : 'loc ->
  ('loc, 'loc) Ast.JSX.SpreadAttribute.t' ->
  ('loc, 'loc) Ast.JSX.SpreadAttribute.t'

method jsx_attribute : ('loc, 'loc) Flow_ast.JSX.Attribute.t ->
  ('loc, 'loc) Flow_ast.JSX.Attribute.t

method jsx_attribute_name : ('loc, 'loc) Ast.JSX.Attribute.name ->
  ('loc, 'loc) Ast.JSX.Attribute.name

method jsx_attribute_name_identifier : ('loc, 'loc) Flow_ast.JSX.Identifier.t ->
  ('loc, 'loc) Flow_ast.JSX.Identifier.t

method jsx_attribute_name_namespaced : ('loc, 'loc)
                                         Flow_ast.JSX.NamespacedName.t ->
  ('loc, 'loc) Flow_ast.JSX.NamespacedName.t

method jsx_attribute_value : ('loc, 'loc) Ast.JSX.Attribute.value ->
  ('loc, 'loc) Ast.JSX.Attribute.value

method jsx_attribute_value_expression : 'loc ->
  ('loc, 'loc) Ast.JSX.ExpressionContainer.t ->
  ('loc, 'loc) Ast.JSX.ExpressionContainer.t

method jsx_attribute_value_literal : 'loc ->
  'loc Ast.StringLiteral.t ->
  'loc Ast.StringLiteral.t

method jsx_children : ('loc * ('loc, 'loc) Ast.JSX.child list) ->
  'loc * ('loc, 'loc) Ast.JSX.child list

method jsx_child : ('loc, 'loc) Ast.JSX.child -> ('loc, 'loc) Ast.JSX.child

method jsx_expression : 'loc ->
  ('loc, 'loc) Ast.JSX.ExpressionContainer.t ->
  ('loc, 'loc) Ast.JSX.ExpressionContainer.t

method jsx_spread_child : ('loc, 'loc) Ast.JSX.SpreadChild.t ->
  ('loc, 'loc) Ast.JSX.SpreadChild.t

method jsx_element_name : ('loc, 'loc) Ast.JSX.name ->
  ('loc, 'loc) Ast.JSX.name

method jsx_element_name_identifier : ('loc, 'loc) Ast.JSX.Identifier.t ->
  ('loc, 'loc) Ast.JSX.Identifier.t

method jsx_element_name_namespaced : ('loc, 'loc) Ast.JSX.NamespacedName.t ->
  ('loc, 'loc) Ast.JSX.NamespacedName.t

method jsx_element_name_member_expression : ('loc, 'loc)
                                              Ast.JSX.MemberExpression.t ->
  ('loc, 'loc) Ast.JSX.MemberExpression.t

method jsx_namespaced_name : ('loc, 'loc) Flow_ast.JSX.NamespacedName.t ->
  ('loc, 'loc) Flow_ast.JSX.NamespacedName.t

method jsx_member_expression : ('loc, 'loc) Ast.JSX.MemberExpression.t ->
  ('loc, 'loc) Ast.JSX.MemberExpression.t

method jsx_member_expression_object : ('loc, 'loc)
                                        Ast.JSX.MemberExpression._object ->
  ('loc, 'loc) Ast.JSX.MemberExpression._object

method jsx_member_expression_identifier : ('loc, 'loc)
                                            Flow_ast.JSX.Identifier.t ->
  ('loc, 'loc) Flow_ast.JSX.Identifier.t

method jsx_identifier : ('loc, 'loc) Flow_ast.JSX.Identifier.t ->
  ('loc, 'loc) Flow_ast.JSX.Identifier.t

method labeled_statement : 'loc ->
  ('loc, 'loc) Ast.Statement.Labeled.t ->
  ('loc, 'loc) Ast.Statement.Labeled.t

method logical : 'loc ->
  ('loc, 'loc) Ast.Expression.Logical.t ->
  ('loc, 'loc) Ast.Expression.Logical.t

method member : 'loc ->
  ('loc, 'loc) Ast.Expression.Member.t ->
  ('loc, 'loc) Ast.Expression.Member.t

method optional_member : 'loc ->
  ('loc, 'loc) Ast.Expression.OptionalMember.t ->
  ('loc, 'loc) Ast.Expression.OptionalMember.t

method member_property : ('loc, 'loc) Ast.Expression.Member.property ->
  ('loc, 'loc) Ast.Expression.Member.property

method member_property_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method member_private_name : 'loc Flow_ast.PrivateName.t ->
  'loc Flow_ast.PrivateName.t

method member_property_expression : ('loc, 'loc) Flow_ast.Expression.t ->
  ('loc, 'loc) Flow_ast.Expression.t

method meta_property : 'loc ->
  'loc Ast.Expression.MetaProperty.t ->
  'loc Ast.Expression.MetaProperty.t

method new_ : 'loc ->
  ('loc, 'loc) Ast.Expression.New.t ->
  ('loc, 'loc) Ast.Expression.New.t

method object_ : 'loc ->
  ('loc, 'loc) Ast.Expression.Object.t ->
  ('loc, 'loc) Ast.Expression.Object.t

method object_property : ('loc, 'loc) Ast.Expression.Object.Property.t ->
  ('loc, 'loc) Ast.Expression.Object.Property.t

method object_key : ('loc, 'loc) Ast.Expression.Object.Property.key ->
  ('loc, 'loc) Ast.Expression.Object.Property.key

method object_key_string_literal : ('loc * 'loc Ast.StringLiteral.t) ->
  'loc * 'loc Ast.StringLiteral.t

method object_key_number_literal : ('loc * 'loc Ast.NumberLiteral.t) ->
  'loc * 'loc Ast.NumberLiteral.t

method object_key_bigint_literal : ('loc * 'loc Ast.BigIntLiteral.t) ->
  'loc * 'loc Ast.BigIntLiteral.t

method object_key_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method object_key_computed : ('loc, 'loc) Flow_ast.ComputedKey.t ->
  ('loc, 'loc) Flow_ast.ComputedKey.t

method opaque_type : 'loc ->
  ('loc, 'loc) Ast.Statement.OpaqueType.t ->
  ('loc, 'loc) Ast.Statement.OpaqueType.t

method function_param_pattern : ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method variable_declarator_pattern : kind:Ast.Variable.kind ->
  ('loc, 'loc) Ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method catch_clause_pattern : ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method for_in_assignment_pattern : ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method for_of_assignment_pattern : ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method binding_pattern : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method assignment_pattern : ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method pattern : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method pattern_identifier : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method pattern_string_literal : ?kind:Ast.Variable.kind ->
  'loc ->
  'loc Ast.StringLiteral.t ->
  'loc Ast.StringLiteral.t

method pattern_number_literal : ?kind:Ast.Variable.kind ->
  'loc ->
  'loc Ast.NumberLiteral.t ->
  'loc Ast.NumberLiteral.t

method pattern_bigint_literal : ?kind:Ast.Variable.kind ->
  'loc ->
  'loc Ast.BigIntLiteral.t ->
  'loc Ast.BigIntLiteral.t

method pattern_object_p : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Ast.Pattern.Object.property ->
  ('loc, 'loc) Ast.Pattern.Object.property

method pattern_object_property : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Ast.Pattern.Object.Property.t ->
  ('loc, 'loc) Ast.Pattern.Object.Property.t

method pattern_object_property_key : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Ast.Pattern.Object.Property.key ->
  ('loc, 'loc) Ast.Pattern.Object.Property.key

method pattern_object_property_string_literal_key : ?kind:Ast.Variable.kind ->
  ('loc * 'loc Ast.StringLiteral.t) ->
  'loc * 'loc Ast.StringLiteral.t

method pattern_object_property_number_literal_key : ?kind:Ast.Variable.kind ->
  ('loc * 'loc Ast.NumberLiteral.t) ->
  'loc * 'loc Ast.NumberLiteral.t

method pattern_object_property_bigint_literal_key : ?kind:Ast.Variable.kind ->
  ('loc * 'loc Ast.BigIntLiteral.t) ->
  'loc * 'loc Ast.BigIntLiteral.t

method pattern_object_property_identifier_key : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method pattern_object_property_computed_key : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Flow_ast.ComputedKey.t ->
  ('loc, 'loc) Flow_ast.ComputedKey.t

method pattern_object_rest_property : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Flow_ast.Pattern.RestElement.t ->
  ('loc, 'loc) Flow_ast.Pattern.RestElement.t

method pattern_object_property_pattern : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method pattern_object_rest_property_pattern : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method pattern_array_e : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Ast.Pattern.Array.element ->
  ('loc, 'loc) Ast.Pattern.Array.element

method pattern_array_element : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Ast.Pattern.Array.Element.t ->
  ('loc, 'loc) Ast.Pattern.Array.Element.t

method pattern_array_element_pattern : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method pattern_array_rest_element : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Flow_ast.Pattern.RestElement.t ->
  ('loc, 'loc) Flow_ast.Pattern.RestElement.t

method pattern_array_rest_element_pattern : ?kind:Ast.Variable.kind ->
  ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method pattern_expression : ('loc, 'loc) Flow_ast.Expression.t ->
  ('loc, 'loc) Flow_ast.Expression.t

method predicate : ('loc, 'loc) Flow_ast.Type.Predicate.t ->
  ('loc, 'loc) Flow_ast.Type.Predicate.t

method predicate_expression : ('loc, 'loc) Flow_ast.Expression.t ->
  ('loc, 'loc) Flow_ast.Expression.t

method type_guard_annotation : ('loc, 'loc) Flow_ast.Type.type_guard_annotation ->
  ('loc, 'loc) Flow_ast.Type.type_guard_annotation

method type_guard : ('loc, 'loc) Flow_ast.Type.TypeGuard.t ->
  ('loc, 'loc) Flow_ast.Type.TypeGuard.t

method function_rest_param : ('loc, 'loc) Flow_ast.Function.RestParam.t ->
  ('loc, 'loc) Flow_ast.Function.RestParam.t

method return : 'loc ->
  ('loc, 'loc) Ast.Statement.Return.t ->
  ('loc, 'loc) Ast.Statement.Return.t

method sequence : 'loc ->
  ('loc, 'loc) Ast.Expression.Sequence.t ->
  ('loc, 'loc) Ast.Expression.Sequence.t

method toplevel_statement_list : ('loc, 'loc) Flow_ast.Statement.t list ->
  ('loc, 'loc) Flow_ast.Statement.t list

method statement_list : ('loc, 'loc) Flow_ast.Statement.t list ->
  ('loc, 'loc) Flow_ast.Statement.t list

method statement_fork_point : ('loc, 'loc) Ast.Statement.t ->
  ('loc, 'loc) Ast.Statement.t list

method spread_element : ('loc, 'loc) Flow_ast.Expression.SpreadElement.t ->
  ('loc, 'loc) Flow_ast.Expression.SpreadElement.t

method spread_property : ('loc, 'loc) Ast.Expression.Object.SpreadProperty.t ->
  ('loc, 'loc) Ast.Expression.Object.SpreadProperty.t

method super_expression : 'loc ->
  'loc Ast.Expression.Super.t ->
  'loc Ast.Expression.Super.t

method switch : 'loc ->
  ('loc, 'loc) Ast.Statement.Switch.t ->
  ('loc, 'loc) Ast.Statement.Switch.t

method switch_case : ('loc, 'loc) Ast.Statement.Switch.Case.t ->
  ('loc, 'loc) Ast.Statement.Switch.Case.t

method tagged_template : 'loc ->
  ('loc, 'loc) Ast.Expression.TaggedTemplate.t ->
  ('loc, 'loc) Ast.Expression.TaggedTemplate.t

method template_literal : 'loc ->
  ('loc, 'loc) Ast.Expression.TemplateLiteral.t ->
  ('loc, 'loc) Ast.Expression.TemplateLiteral.t

method template_literal_element : 'loc Ast.Expression.TemplateLiteral.Element.t ->
  'loc Ast.Expression.TemplateLiteral.Element.t

method this_expression : 'loc ->
  'loc Ast.Expression.This.t ->
  'loc Ast.Expression.This.t

method throw : 'loc ->
  ('loc, 'loc) Ast.Statement.Throw.t ->
  ('loc, 'loc) Ast.Statement.Throw.t

method try_catch : 'loc ->
  ('loc, 'loc) Ast.Statement.Try.t ->
  ('loc, 'loc) Ast.Statement.Try.t

method type_cast : 'loc ->
  ('loc, 'loc) Ast.Expression.TypeCast.t ->
  ('loc, 'loc) Ast.Expression.TypeCast.t

method ts_satisfies : 'loc ->
  ('loc, 'loc) Ast.Expression.TSSatisfies.t ->
  ('loc, 'loc) Ast.Expression.TSSatisfies.t

method unary_expression : 'loc ->
  ('loc, 'loc) Ast.Expression.Unary.t ->
  ('loc, 'loc) Ast.Expression.Unary.t

method update_expression : 'loc ->
  ('loc, 'loc) Ast.Expression.Update.t ->
  ('loc, 'loc) Ast.Expression.Update.t

method variable_declaration : 'loc ->
  ('loc, 'loc) Ast.Statement.VariableDeclaration.t ->
  ('loc, 'loc) Ast.Statement.VariableDeclaration.t

method variable_declarator : kind:Ast.Variable.kind ->
  ('loc, 'loc) Ast.Statement.VariableDeclaration.Declarator.t ->
  ('loc, 'loc) Ast.Statement.VariableDeclaration.Declarator.t

method while_ : 'loc ->
  ('loc, 'loc) Ast.Statement.While.t ->
  ('loc, 'loc) Ast.Statement.While.t

method with_ : 'loc ->
  ('loc, 'loc) Ast.Statement.With.t ->
  ('loc, 'loc) Ast.Statement.With.t

method type_alias : 'loc ->
  ('loc, 'loc) Ast.Statement.TypeAlias.t ->
  ('loc, 'loc) Ast.Statement.TypeAlias.t

method yield : 'loc ->
  ('loc, 'loc) Ast.Expression.Yield.t ->
  ('loc, 'loc) Ast.Expression.Yield.t