///|
fn ast_long_ident(name : String, pkg : String?) -> @syntax.LongIdent {
  match pkg {
    Some(pkg) => Dot(pkg~, id=name)
    None => Ident(name~)
  }
}

///|
fn ast_var(name : String, pkg : String?) -> @syntax.Var {
  { name: ast_long_ident(name, pkg), loc: @syntax.no_location, }
}

///|
fn ast_binder(name : String) -> @syntax.Binder {
  { name, loc: @syntax.no_location, }
}

///|
fn ast_label(name : String) -> @syntax.Label {
  { name, loc: @syntax.no_location, }
}

///|
fn ast_type_name(name : String, pkg? : String) -> @syntax.TypeName {
  {
    name: ast_long_ident(name, pkg),
    is_object: false,
    loc: @syntax.no_location,
  }
}

///|
fn ast_type(
  name : String,
  args~ : Array[@syntax.Type] = [],
  pkg? : String,
) -> @syntax.Type {
  let loc = @syntax.no_location
  Name(
    constr_id={ id: ast_long_ident(name, pkg), loc, },
    tys=@list.List(args),
    loc~,
  )
}

///|
fn ast_ident(name : String, pkg? : String) -> @syntax.Expr {
  Ident(id=ast_var(name, pkg), loc=@syntax.no_location)
}

///|
fn ast_method(
  type_name : String,
  method_id : String,
  pkg? : String,
) -> @syntax.Expr {
  Method(
    type_name=ast_type_name(type_name, pkg?),
    method_name=ast_label(method_id),
    loc=@syntax.no_location,
  )
}

///|
fn ast_call(
  func : @syntax.Expr,
  args : Array[@syntax.Argument],
) -> @syntax.Expr {
  Apply(func~, args=@list.List(args), loc=@syntax.no_location)
}

///|
fn ast_arg(value : @syntax.Expr) -> @syntax.Argument {
  { value, kind: Positional, }
}

///|
fn ast_named_arg(name : String, value : @syntax.Expr) -> @syntax.Argument {
  { value, kind: Labelled(ast_label(name)), }
}

///|
fn ast_dot_call(
  receiver : @syntax.Expr,
  method_id : String,
  args : Array[@syntax.Argument],
) -> @syntax.Expr {
  DotApply(
    self=receiver,
    method_name=ast_label(method_id),
    args=@list.List(args),
    return_self=false,
    loc=@syntax.no_location,
  )
}

///|
fn ast_field(receiver : @syntax.Expr, name : String) -> @syntax.Expr {
  Field(
    record=receiver,
    accessor=Label(ast_label(name)),
    loc=@syntax.no_location,
  )
}

///|
fn ast_string_constant(value : String) -> @syntax.Constant {
  // The literal is an escaped lexeme without its surrounding quotes.
  String(value.escape(quote=false))
}

///|
fn ast_string(value : String) -> @syntax.Expr {
  Constant(c=ast_string_constant(value), loc=@syntax.no_location)
}

///|
fn ast_int(value : Int32) -> @syntax.Expr {
  Constant(c=Int(value.to_string()), loc=@syntax.no_location)
}

///|
fn ast_array(exprs : Array[@syntax.Expr]) -> @syntax.Expr {
  Array(exprs=@list.List(exprs), is_iter=false, loc=@syntax.no_location)
}

///|
fn ast_index(array : @syntax.Expr, index : @syntax.Expr) -> @syntax.Expr {
  ArrayGet(array~, index~, loc=@syntax.no_location)
}

///|
fn ast_case(pattern : @syntax.Pattern, body : @syntax.Expr) -> @syntax.Case {
  { pattern, guard_: None, body, }
}

///|
fn ast_match(expr : @syntax.Expr, cases : Array[@syntax.Case]) -> @syntax.Expr {
  let loc = @syntax.no_location
  Match(expr~, cases=@list.List(cases), match_loc=loc, loc~)
}

///|
fn ast_bind(name : String) -> @syntax.Pattern {
  Var(ast_binder(name))
}

///|
fn ast_any() -> @syntax.Pattern {
  Any(loc=@syntax.no_location)
}

///|
fn ast_constructor(name : String) -> @syntax.Constructor {
  let loc = @syntax.no_location
  { name: { name, loc, }, extra_info: NoExtraInfo, loc, }
}

///|
fn ast_ctor(name : String) -> @syntax.Expr {
  Constr(constr=ast_constructor(name), loc=@syntax.no_location)
}

///|
fn ast_ctor_pat(
  name : String,
  args : Array[@syntax.ConstrPatArg],
) -> @syntax.Pattern {
  Constr(
    constr=ast_constructor(name),
    args=if args.is_empty() { None } else { Some(@list.List(args)) },
    is_open=false,
    loc=@syntax.no_location,
  )
}

///|
fn ast_pat_arg(pat : @syntax.Pattern, label? : String) -> @syntax.ConstrPatArg {
  {
    pat,
    kind: match label {
      Some(name) => Labelled(ast_label(name))
      None => Positional
    },
  }
}

///|
fn ast_string_pat(value : String) -> @syntax.Pattern {
  Constant(c=ast_string_constant(value), loc=@syntax.no_location)
}

///|
fn ast_tuple_pat(pats : Array[@syntax.Pattern]) -> @syntax.Pattern {
  Tuple(pats=@list.List(pats), loc=@syntax.no_location)
}

///|
fn ast_let(
  pattern : @syntax.Pattern,
  expr : @syntax.Expr,
  body : @syntax.Expr,
  ty? : @syntax.Type,
) -> @syntax.Expr {
  let loc = @syntax.no_location
  let pattern = match ty {
    Some(ty) => @syntax.Pattern::Constraint(pat=pattern, ty~, loc~)
    None => pattern
  }
  Let(pattern~, expr~, body~, loc~)
}

///|
fn ast_seq(
  exprs : Array[@syntax.Expr],
  last_expr : @syntax.Expr,
) -> @syntax.Expr {
  if exprs.is_empty() {
    last_expr
  } else {
    Sequence(exprs=@list.List(exprs), last_expr~, loc=@syntax.no_location)
  }
}

///|
fn ast_record(fields : Array[(String, @syntax.Expr)]) -> @syntax.Expr {
  let loc = @syntax.no_location
  let fields : Array[@syntax.FieldDef] = fields.map(fn(field) {
    let (name, expr) = field
    { label: ast_label(name), expr, is_pun: false, loc, }
  })
  Record(type_name=None, fields=@list.List(fields), trailing=Comma, loc~)
}

///|
fn ast_map(elems : Array[(String, @syntax.Expr)]) -> @syntax.Expr {
  let loc = @syntax.no_location
  let elems : Array[@syntax.MapExprElem] = elems.map(fn(elem) {
    let (key, expr) = elem
    { key: ast_string_constant(key), expr, key_loc: loc, loc, }
  })
  Map(elems=@list.List(elems), loc~)
}

///|
fn ast_if(
  cond : @syntax.Expr,
  ifso : @syntax.Expr,
  else_? : @syntax.Expr,
) -> @syntax.Expr {
  If(cond~, ifso~, ifnot=else_, loc=@syntax.no_location)
}

///|
fn ast_is(expr : @syntax.Expr, pat : @syntax.Pattern) -> @syntax.Expr {
  Is(expr~, pat~, loc=@syntax.no_location)
}

///|
fn ast_infix(
  op : String,
  lhs : @syntax.Expr,
  rhs : @syntax.Expr,
) -> @syntax.Expr {
  Infix(op=ast_var(op, None), lhs~, rhs~, loc=@syntax.no_location)
}

///|
fn ast_param(name : String, ty? : @syntax.Type) -> @syntax.Parameter {
  Positional(binder=ast_binder(name), ty~)
}

///|
fn ast_impl(
  trait_ : @syntax.TypeName,
  self_ty : @syntax.Type,
  quantifiers : Array[@syntax.TypeVarBinder],
  method_id : String,
  params : Array[@syntax.Parameter],
  body : @syntax.Expr,
  is_private : Bool,
) -> @syntax.Impl {
  let loc = @syntax.no_location
  TopImpl(
    self_ty=Some(self_ty),
    trait_~,
    method_name=ast_binder(method_id),
    quantifiers=@list.List(quantifiers),
    method_quantifiers=@list.List([]),
    params=@list.List(params),
    ret_ty=None,
    err_ty=NoErrorType,
    nocancel_=None,
    body=DeclBody(expr=body),
    vis=if is_private { Default } else { Pub(attr=None, loc~) },
    loc~,
    attrs=@list.List([]),
    doc=@syntax.DocString::empty(),
  )
}

///|
fn ast_func(
  name : String,
  quantifiers : Array[@syntax.TypeVarBinder],
  params : Array[@syntax.Parameter],
  ret_ty : @syntax.Type,
  err_ty : @syntax.Type,
  body : @syntax.Expr,
) -> @syntax.Impl {
  let loc = @syntax.no_location
  let fun_decl : @syntax.FunDecl = {
    type_name: None,
    name: ast_binder(name),
    is_async: None,
    decl_params: Some(@list.List(params)),
    params_loc: loc,
    quantifiers: @list.List(quantifiers),
    return_type: Some(ret_ty),
    error_type: ErrorType(ty=err_ty),
    nocancel_: None,
    vis: Default,
    attrs: @list.List([]),
    doc: @syntax.DocString::empty(),
    loc,
  }
  TopFuncDef(fun_decl~, decl_body=DeclBody(expr=body), where_clause=None, loc~)
}