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
- Declaration_parser
  - DECLARATION
  - Declaration
    
    Parse
    
    Type
  - SSet
- Enum_common
- Enum_parser
  - Enum
    
    Parse
  - SSet
- Expression_parser
  - EXPRESSION
  - Expression
    
    Declaration
    
    Parse
    
    Pattern_cover
    
    Type
- File_key
- Flow_ast
  - BigIntLiteral
  - BooleanLiteral
  - Class
    
    Body
    
    Decorator
    
    Extends
    
    Implements
    
    Interface
    
    Method
    
    PrivateField
    
    Property
  - Comment
  - ComputedKey
  - Expression
    
    ArgList
    
    Array
    
    Assignment
    
    Binary
    
    Call
    
    CallTypeArg
    
    Implicit
    
    CallTypeArgs
    
    Comprehension
    
    Block
    
    Conditional
    
    Generator
    
    Import
    
    Logical
    
    Member
    
    MetaProperty
    
    New
    
    Object
    
    Property
    
    SpreadProperty
    
    OptionalCall
    
    OptionalMember
    
    Sequence
    
    SpreadElement
    
    Super
    
    TaggedTemplate
    
    TemplateLiteral
    
    Element
    
    This
    
    TypeCast
    
    Unary
    
    Update
    
    Yield
  - Function
    
    Param
    
    Params
    
    RestParam
    
    ThisParam
  - Identifier
  - JSX
    
    Attribute
    
    Closing
    
    ExpressionContainer
    
    Identifier
    
    MemberExpression
    
    NamespacedName
    
    Opening
    
    SpreadAttribute
    
    SpreadChild
    
    Text
  - Literal
    
    RegExp
  - NumberLiteral
  - Pattern
    
    Array
    
    Element
    
    Identifier
    
    Object
    
    Property
    
    RestElement
  - PrivateName
  - Program
  - Statement
    
    Block
    
    Break
    
    Continue
    
    Debugger
    
    DeclareClass
    
    DeclareExportDeclaration
    
    DeclareFunction
    
    DeclareModule
    
    DeclareModuleExports
    
    DeclareVariable
    
    DoWhile
    
    Empty
    
    EnumDeclaration
    
    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
    
    Function
    
    Param
    
    Params
    
    RestParam
    
    ThisParam
    
    Generic
    
    Identifier
    
    IndexedAccess
    
    Interface
    
    Intersection
    
    Nullable
    
    Object
    
    CallProperty
    
    Indexer
    
    InternalSlot
    
    Property
    
    SpreadProperty
    
    OptionalIndexedAccess
    
    Predicate
    
    Tuple
    
    TypeArgs
    
    TypeParam
    
    TypeParams
    
    Typeof
    
    Union
  - Variance
- Flow_ast_mapper
  - mapper
- Flow_ast_utils
  - ExpressionSort
- Flow_lexer
- Jsx_parser
  - JSX
    
    Parse
- Lex_env
- Lex_result
- Loc
- Object_parser
  - OBJECT
  - Object
    
    Declaration
    
    Expression
    
    Parse
    
    Pattern_cover
    
    Type
  - SMap
- Parse_error
  - PP
- Parser_common
  - PARSER
- Parser_env
  - Eat
  - Expect
  - Lex_mode
  - Peek
  - SSet
  - Try
- Parser_flow
  - Parse
- Pattern_cover
  - COVER
  - Cover
    
    Parse
- Pattern_parser
  - Pattern
    
    Parse
    
    Type
- Statement_parser
  - SSet
  - STATEMENT
  - Statement
    
    Declaration
    
    Object
    
    Parse
    
    Pattern_cover
    
    Type
- Token
- Type_parser
  - TYPE
  - Type
    
    Parse

Legend:
Library
Module
Module type
Parameter
Class
Class type

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 array_type : ('loc, 'loc) Ast.Type.Array.t ->
  ('loc, 'loc) Ast.Type.Array.t

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

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

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

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

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

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

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

method boolean_literal_type : 'loc ->
  'loc Ast.BooleanLiteral.t ->
  'loc Ast.BooleanLiteral.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 call_arguments : ('loc, 'loc) Flow_ast.Expression.ArgList.t ->
  ('loc, 'loc) Flow_ast.Expression.ArgList.t

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

method call_type_args : ('loc, 'loc) Flow_ast.Expression.CallTypeArgs.t ->
  ('loc, 'loc) Flow_ast.Expression.CallTypeArgs.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 catch_clause_pattern : ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.t

method class_ : 'loc -> ('loc, 'loc) Ast.Class.t -> ('loc, 'loc) Ast.Class.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_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_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_private_field : 'loc ->
  ('loc, 'loc) Ast.Class.PrivateField.t' ->
  ('loc, 'loc) Ast.Class.PrivateField.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 comment : 'loc Flow_ast.Comment.t -> 'loc Flow_ast.Comment.t

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

method computed_key : ('loc, 'loc) Ast.ComputedKey.t ->
  ('loc, 'loc) Ast.ComputedKey.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_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_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_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_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_declaration : 'loc ->
  ('loc, 'loc) Ast.Statement.EnumDeclaration.t ->
  ('loc, 'loc) Ast.Statement.EnumDeclaration.t

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

method enum_number_body : 'loc Ast.Statement.EnumDeclaration.NumberBody.t ->
  'loc Ast.Statement.EnumDeclaration.NumberBody.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_body : 'loc Ast.Statement.EnumDeclaration.StringBody.t ->
  'loc Ast.Statement.EnumDeclaration.StringBody.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_symbol_body : 'loc Ast.Statement.EnumDeclaration.SymbolBody.t ->
  'loc Ast.Statement.EnumDeclaration.SymbolBody.t

method export_batch_specifier : 'loc
                                  Ast.Statement.ExportNamedDeclaration.ExportBatchSpecifier.t ->
  'loc Ast.Statement.ExportNamedDeclaration.ExportBatchSpecifier.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
                                              Ast.Statement.ExportNamedDeclaration.ExportSpecifier.t ->
  'loc Ast.Statement.ExportNamedDeclaration.ExportSpecifier.t

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

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

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

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

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

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

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_init_declaration : ('loc
                               * ('loc, 'loc)
                                   Ast.Statement.VariableDeclaration.t) ->
  'loc * ('loc, 'loc) Ast.Statement.VariableDeclaration.t

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

method for_of_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_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 function_ : 'loc ->
  ('loc, 'loc) Ast.Function.t ->
  ('loc, 'loc) Ast.Function.t

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

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

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_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

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

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

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

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

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

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

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

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

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

method generator : 'loc ->
  ('loc, 'loc) Ast.Expression.Generator.t ->
  ('loc, 'loc) Ast.Expression.Generator.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 generic_type : 'loc ->
  ('loc, 'loc) Ast.Type.Generic.t ->
  ('loc, 'loc) Ast.Type.Generic.t

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

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

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

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

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

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

method import_default_specifier : ('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_namespace_specifier : 'loc ->
  ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

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

method indexed_access : 'loc ->
  ('loc, 'loc) Ast.Type.IndexedAccess.t ->
  ('loc, 'loc) Ast.Type.IndexedAccess.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 interface_type : 'loc ->
  ('loc, 'loc) Ast.Type.Interface.t ->
  ('loc, 'loc) Ast.Type.Interface.t

method intersection_type : 'loc ->
  ('loc, 'loc) Ast.Type.Intersection.t ->
  ('loc, 'loc) Ast.Type.Intersection.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.Literal.t ->
  'loc Ast.Literal.t

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

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

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

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

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_member_expression : ('loc, 'loc)
                                              Ast.JSX.MemberExpression.t ->
  ('loc, 'loc) Ast.JSX.MemberExpression.t

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

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

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

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

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

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

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

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

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

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

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

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

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

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

method literal : 'loc -> 'loc Ast.Literal.t -> 'loc Ast.Literal.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 member_private_name : 'loc Flow_ast.PrivateName.t ->
  'loc Flow_ast.PrivateName.t

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

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

method member_property_identifier : ('loc, 'loc) Flow_ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.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 nullable_type : ('loc, 'loc) Ast.Type.Nullable.t ->
  ('loc, 'loc) Ast.Type.Nullable.t

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

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

method object_call_property_type : ('loc, 'loc) Ast.Type.Object.CallProperty.t ->
  ('loc, 'loc) Ast.Type.Object.CallProperty.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_key : ('loc, 'loc) Ast.Expression.Object.Property.key ->
  ('loc, 'loc) Ast.Expression.Object.Property.key

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

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

method object_key_literal : ('loc * 'loc Ast.Literal.t) ->
  'loc * 'loc Ast.Literal.t

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

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

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

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

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

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 opaque_type : 'loc ->
  ('loc, 'loc) Ast.Statement.OpaqueType.t ->
  ('loc, 'loc) Ast.Statement.OpaqueType.t

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

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

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

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

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

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

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

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

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

method pattern_assignment_pattern : ?kind:
                                      Ast.Statement.VariableDeclaration.kind ->
  ('loc, 'loc) 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 pattern_identifier : ?kind:Ast.Statement.VariableDeclaration.kind ->
  ('loc, 'loc) Ast.Identifier.t ->
  ('loc, 'loc) Flow_ast.Identifier.t

method pattern_literal : ?kind:Ast.Statement.VariableDeclaration.kind ->
  'loc ->
  'loc Ast.Literal.t ->
  'loc Ast.Literal.t

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

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

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

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

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

method pattern_object_property_literal_key : ?kind:
                                               Ast.Statement.VariableDeclaration.kind ->
  ('loc * 'loc Ast.Literal.t) ->
  'loc * 'loc Ast.Literal.t

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

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

method pattern_object_rest_property_pattern : ?kind:
                                                Ast.Statement.VariableDeclaration.kind ->
  ('loc, 'loc) Flow_ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.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 private_name : 'loc Flow_ast.PrivateName.t ->
  'loc Flow_ast.PrivateName.t

method program : ('loc, 'loc) Ast.Program.t -> ('loc, 'loc) Ast.Program.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 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 statement : ('loc, 'loc) Ast.Statement.t -> ('loc, 'loc) Ast.Statement.t

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

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

method string_literal_type : 'loc ->
  'loc Ast.StringLiteral.t ->
  'loc Ast.StringLiteral.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 syntax : 'internal. ('loc, 'internal) Ast.Syntax.t ->
  ('loc, 'internal) Ast.Syntax.t

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

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 toplevel_statement_list : ('loc, 'loc) Flow_ast.Statement.t list ->
  ('loc, 'loc) Flow_ast.Statement.t list

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

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

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

method type_alias : 'loc ->
  ('loc, 'loc) Ast.Statement.TypeAlias.t ->
  ('loc, 'loc) Ast.Statement.TypeAlias.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 type_args : ('loc, 'loc) Flow_ast.Type.TypeArgs.t ->
  ('loc, 'loc) Flow_ast.Type.TypeArgs.t

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

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

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

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

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

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

method union_type : 'loc ->
  ('loc, 'loc) Ast.Type.Union.t ->
  ('loc, 'loc) Ast.Type.Union.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.Statement.VariableDeclaration.kind ->
  ('loc, 'loc) Ast.Statement.VariableDeclaration.Declarator.t ->
  ('loc, 'loc) Ast.Statement.VariableDeclaration.Declarator.t

method variable_declarator_pattern : kind:
                                       Ast.Statement.VariableDeclaration.kind ->
  ('loc, 'loc) Ast.Pattern.t ->
  ('loc, 'loc) Flow_ast.Pattern.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 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 yield : 'loc ->
  ('loc, 'loc) Ast.Expression.Yield.t ->
  ('loc, 'loc) Ast.Expression.Yield.t