Expression (melange.Js_parser.Flow

module CallTypeArg: { ... };

module CallTypeArgs: { ... };

module SpreadElement: { ... };

module Array: { ... };

module TemplateLiteral: { ... };

module TaggedTemplate: { ... };

module Object: { ... };

module Sequence: { ... };

module Unary: { ... };

module Binary: { ... };

module Assignment: { ... };

module Update: { ... };

module Logical: { ... };

module Conditional: { ... };

type expression_or_spread('M, 'T) =

| Expression(Expression.t('M, 'T))
| Spread(SpreadElement.t('M, 'T))

;

let pp_expression_or_spread: 
  (Format.formatter => 'M => unit) =>
  (Format.formatter => 'T => unit) =>
  Format.formatter =>
  expression_or_spread('M, 'T) =>
  unit;

let show_expression_or_spread: 
  (Format.formatter => 'M => unit) =>
  (Format.formatter => 'T => unit) =>
  expression_or_spread('M, 'T) =>
  string;

module ArgList: { ... };

module New: { ... };

module Call: { ... };

module OptionalCall: { ... };

module Member: { ... };

module OptionalMember: { ... };

module Yield: { ... };

module TypeCast: { ... };

module AsExpression: { ... };

module AsConstExpression: { ... };

module TSSatisfies: { ... };

module MetaProperty: { ... };

module This: { ... };

module Super: { ... };

module Import: { ... };

type match_expression('M, 'T) = Match.t('M, 'T, Expression.t('M, 'T));

let pp_match_expression: 
  (Format.formatter => 'M => unit) =>
  (Format.formatter => 'T => unit) =>
  Format.formatter =>
  match_expression('M, 'T) =>
  unit;

let show_match_expression: 
  (Format.formatter => 'M => unit) =>
  (Format.formatter => 'T => unit) =>
  match_expression('M, 'T) =>
  string;

type t('M, 'T) = ('T, t'('M, 'T));

and t'('M, 'T) =

| Array(Array.t('M, 'T))
| ArrowFunction(Function.t('M, 'T))
| AsConstExpression(AsConstExpression.t('M, 'T))
| AsExpression(AsExpression.t('M, 'T))
| Assignment(Assignment.t('M, 'T))
| Binary(Binary.t('M, 'T))
| Call(Call.t('M, 'T))
| Class(Class.t('M, 'T))
| Conditional(Conditional.t('M, 'T))
| Function(Function.t('M, 'T))
| Identifier(Identifier.t('M, 'T))
| Import(Import.t('M, 'T))
| JSXElement(JSX.element('M, 'T))
| JSXFragment(JSX.fragment('M, 'T))
| StringLiteral(StringLiteral.t('M))
| BooleanLiteral(BooleanLiteral.t('M))
| NullLiteral(option(Syntax.t('M, unit)))
| NumberLiteral(NumberLiteral.t('M))
| BigIntLiteral(BigIntLiteral.t('M))
| RegExpLiteral(RegExpLiteral.t('M))
| ModuleRefLiteral(ModuleRefLiteral.t('M, 'T))
| Logical(Logical.t('M, 'T))
| Match(match_expression('M, 'T))
| Member(Member.t('M, 'T))
| MetaProperty(MetaProperty.t('M))
| New(New.t('M, 'T))
| Object(Object.t('M, 'T))
| OptionalCall(OptionalCall.t('M, 'T))
| OptionalMember(OptionalMember.t('M, 'T))
| Sequence(Sequence.t('M, 'T))
| Super(Super.t('M))
| TaggedTemplate(TaggedTemplate.t('M, 'T))
| TemplateLiteral(TemplateLiteral.t('M, 'T))
| This(This.t('M))
| TypeCast(TypeCast.t('M, 'T))
| TSSatisfies(TSSatisfies.t('M, 'T))
| Unary(Unary.t('M, 'T))
| Update(Update.t('M, 'T))
| Yield(Yield.t('M, 'T))

;

let pp: 
  (Format.formatter => 'M => unit) =>
  (Format.formatter => 'T => unit) =>
  Format.formatter =>
  t('M, 'T) =>
  unit;

let show: 
  (Format.formatter => 'M => unit) =>
  (Format.formatter => 'T => unit) =>
  t('M, 'T) =>
  string;

let pp_t': 
  (Format.formatter => 'M => unit) =>
  (Format.formatter => 'T => unit) =>
  Format.formatter =>
  t'('M, 'T) =>
  unit;

let show_t': 
  (Format.formatter => 'M => unit) =>
  (Format.formatter => 'T => unit) =>
  t'('M, 'T) =>
  string;