DanielXMoore / Civet / 22318263782

import type {

  AmpersandBlockBody

  ArrayBindingPattern

  ASTError

  ASTLeaf

  ASTNode

  ASTNodeObject

  Binding

  BindingElement

  BindingIdentifier

  BlockStatement

  BreakStatement

  CallExpression

  Children

  Declaration

  ForStatement

  FunctionNode

  FunctionParameter

  FunctionRestParameter

  IterationExpression

  IterationFamily

  IterationStatement

  Parameter

  ParametersNode

  PostRestBindingElements

  ReturnTypeAnnotation

  StatementTuple

  SwitchStatement

  ThisType

  TypeArgument

  TypeArguments

  TypeIdentifier

  TypeLiteral

  TypeNode

  TypeSuffix

  Whitespace

} from ./types.civet

import {

  braceBlock

  getIndent

  blockContainingStatement

  makeEmptyBlock

} from ./block.civet

import {

  gatherSubbindings

  gatherBindingCode

  gatherBindingPatternTypeSuffix

  simplifyBindingProperties

} from ./binding.civet

import {

  expressionizeComptime

} from ./comptime.civet

import {

  getHelperRef

} from ./helper.civet

import {

  findAncestor

  findChildIndex

  gatherNodes

  gatherRecursive

  gatherRecursiveAll

  gatherRecursiveWithinFunction

  type Predicate

} from ./traversal.civet

import {

  addParentPointers

  assert

  convertOptionalType

  deepCopy

  getTrimmingSpace

  hasAwait

  hasTrailingComment

  hasYield

  inplacePrepend

  isEmptyBareBlock

  isExit

  isFunction

  isLoopStatement

  isStatement

  isWhitespaceOrEmpty

  makeLeftHandSideExpression

  makeNode

  replaceNode

  startsWithPredicate

  trimFirstSpace

  updateParentPointers

  wrapIIFE

  wrapWithReturn

} from ./util.civet

import {

  makeRef

} from ./ref.civet

// Extract actual TypeArgument nodes from an array/node that includes them

function getTypeArguments(args: ASTNode): TypeArgument[]

  while args is like {args}

  unless Array.isArray args

  args.filter (is like {type: "TypeArgument"})

function isVoidType(t?: TypeNode): boolean

  t is like { type: "TypeLiteral", t: { type: "VoidType" } }

function isPromiseType(t?: TypeNode): t is TypeIdentifier

  t is like { type: "TypeIdentifier", raw: "Promise" }

function isPromiseVoidType(t?: TypeNode): boolean

  return false unless isPromiseType t

  args := getTypeArguments t.args?.args

  (and)

    args# is 1

    isVoidType args[0].t

function wrapTypeInPromise(t: TypeNode): TypeNode

  return t if isPromiseType t

  // Use raw = "Promise" so that Civet thinks this is a Promise wrapper

  wrapTypeInApplication t, getHelperRef("AutoPromise"), "Promise"

function wrapTypeInApplication(t: TypeNode, id: ASTNode, raw?: string): TypeNode

  ws := getTrimmingSpace t

  t = trimFirstSpace(t) as TypeNode

  innerArgs: TypeArgument[] := [{

    type: "TypeArgument"

    ts: true

    t

    children: [t]

  }]

  args: TypeArguments := {

    type: "TypeArguments"

    ts: true

    args: innerArgs

    children: ["<", innerArgs, ">"]

  }

  unless raw?

    unless id <? "string"

    raw = id

  {

    type: "TypeIdentifier"

    raw

    args

    children: [ws, id, args]

  }

// Add implicit block unless followed by a method/function of the same name.

function implicitFunctionBlock(f): void

  if (f.abstract or f.block or f.signature?.optional) return

  if followingOverloads(f)#

    f.ts = true

  else

    block := makeEmptyBlock()

    block.parent = f

    f.block = block

    f.children.push(block)

    f.ts = false

function overloadsInDirection(f: FunctionNode, direction: number): FunctionNode[]

  return [] unless f.name?

  ancestor .= f.parent

  child: ASTNode .= f

  if ancestor?.type is "ExportDeclaration"

    child = ancestor

    ancestor = ancestor.parent

  return [] unless ancestor?.type is "BlockStatement"

  {expressions} := ancestor

  index .= findChildIndex expressions, child

  if direction < 0

    while --index >= 0

      candidate .= expressions[index][1]

      candidate = candidate.declaration if candidate.type is "ExportDeclaration"

      break unless candidate and candidate.type is f.type and candidate.name is f.name

      candidate

  else

    while ++index < expressions#

      candidate .= expressions[index][1]

      candidate = candidate.declaration if candidate.type is "ExportDeclaration"

      break unless candidate and candidate.type is f.type and candidate.name is f.name

      candidate

function precedingOverloads(f: FunctionNode): FunctionNode[]

  return overloadsInDirection f, -1

function followingOverloads(f: FunctionNode): FunctionNode[]

  return overloadsInDirection f, +1

function processReturn(f: FunctionNode, implicitReturns: boolean): void

  { returnType } .= f.signature

  if returnType and returnType.optional

    convertOptionalType returnType

  if not processReturnValue(f) and

     (implicitReturns or f.signature.implicitReturn)

    { signature, block } := f

    { modifier, name, returnType } := signature

    { async, generator, set } := modifier

    isMethod := f.type is "MethodDefinition"

    isConstructor := isMethod and name is "constructor"

    isVoid := (or)

      generator

      isVoidType returnType?.t

      (and)

        async

        isPromiseVoidType returnType?.t

    if block?.type is "BlockStatement"

      if isVoid or set or isConstructor

        if block.bare and block.implicitlyReturned

          braceBlock block

      else

        unless block.implicitlyReturned

          insertReturn(block)

/**

 * Support for `return.value` and `return =`

 * for changing automatic return value of function.

 * Returns whether any present (so shouldn't do implicit return).

 */

function processReturnValue(func: FunctionNode)

  { block } := func

  values := gatherRecursiveWithinFunction block, .type is "ReturnValue"

  return false unless values#

  ref := makeRef "ret"

  let declaration

  for each value of values

    value.children = [ref]

    // Check whether return.value already declared within this function

    { ancestor, child } := findAncestor

      value

      &.type is "Declaration"

      isFunction

    declaration ??= child if ancestor  // remember binding

  // Compute default return type

  returnType: ReturnTypeAnnotation? .= func.returnType ?? func.signature?.returnType

  if returnType

    { t } := returnType

    switch t.type

      "TypePredicate"

        token := {token: "boolean"} as ASTLeaf

        literal: TypeLiteral :=

          type: "TypeLiteral"

          t: token

          children: [token]

        returnType =

          type: "ReturnTypeAnnotation"

          ts: true

          t: literal

          children: [": ", literal]

      "TypeAsserts"

        returnType = undefined

  if returnType

    returnType = deepCopy returnType

    addParentPointers returnType

    if func.signature.modifier.async

      replaceNode

        returnType.t

        makeNode wrapTypeInApplication returnType.t, "Awaited"

        returnType

  // Modify existing declaration, or add declaration of return.value after {

  if declaration

    unless declaration.typeSuffix?

      declaration.children[1] = declaration.typeSuffix = returnType

  else

    block.expressions.unshift [

      getIndent block.expressions[0]

      makeNode

        type: "Declaration"

        children: ["let ", ref, returnType]

        names: []

      ";"

    ]

  // Transform existing `return` -> `return ret`

  gatherRecursiveWithinFunction block,

    (r) => r.type is "ReturnStatement" and not r.expression

  .forEach (r) =>

    r.expression = ref

    r.children.splice -1, 1, " ", ref

  // Implicit return before }

  unless block.children.-2?.type is "ReturnStatement"

    indent := getIndent block.expressions.-1

    block.expressions.push [

      indent

      wrapWithReturn ref, block, not indent

    ]

  return true

function patternAsValue(pattern: ASTNodeObject): ASTNode

  switch pattern.type

    when "ArrayBindingPattern"

      children := [...pattern.children]

      index := children.indexOf pattern.elements

      elements := children[index] = pattern.elements.map patternAsValue

      { ...pattern, elements, children }

    when "ObjectBindingPattern"

      children := [...pattern.children]

      index := children.indexOf pattern.properties

      properties := children[index] = pattern.properties.map patternAsValue

      { ...pattern, properties, children }

    when "BindingProperty"

      let children: Children

      // { name: value } = ... declares value, not name

      if pattern.value?.type is "Identifier"

        children = [ pattern.value, pattern.delim ]

        // Check for leading whitespace

        if isWhitespaceOrEmpty pattern.children[0]

          children.unshift pattern.children[0]

      else

        children = [...pattern.children]

        if pattern.initializer?

          index := children.indexOf pattern.initializer

          assert.notEqual index, -1, "failed to find initializer in BindingElement"

          children.splice index, 1

        if pattern.value?

          children = children.map & is pattern.value ?

            patternAsValue pattern.value : &

      { ...pattern, children }

    when "AtBindingProperty"

      children := [...pattern.children]

      if pattern.initializer?

        index := children.indexOf pattern.initializer

        assert.notEqual index, -1, "failed to find initializer in AtBindingProperty"

        children.splice index, 1

      { ...pattern, children }

    when "BindingElement"

      children := [...pattern.children]

      if pattern.initializer?

        index := children.indexOf pattern.initializer

        assert.notEqual index, -1, "failed to find initializer in BindingElement"

        children.splice index, 1

      index := children.indexOf pattern.binding

      assert.notEqual index, -1, "failed to find binding in BindingElement"

      children[index] = patternAsValue pattern.binding

      { ...pattern, children }

    else

      pattern

/**

Find all bound variables in a pattern and return as an array

Example: {x: [, y], z} -> [y, z]

*/

function patternBindings(pattern: ASTNodeObject): BindingIdentifier[]

  bindings: BindingIdentifier[] := []

  recurse pattern

  return bindings

  function recurse(pattern: ASTNodeObject): void

    switch pattern.type

      when "ArrayBindingPattern"

        for each element of pattern.elements

          recurse element

      when "ObjectBindingPattern"

        for each property of pattern.properties

          recurse property

      when "BindingElement"

        recurse pattern.binding

      when "BindingProperty"

        recurse pattern.value ?? pattern.name

      when "Identifier", "AtBinding"

        bindings.push pattern

// NOTE: this is almost the same as insertReturn but doesn't remove `breaks` in `when` and

// does construct an else clause pushing undefined in if statements that lack them

// and adds to the beginning and the end of the expression's children.

// Maybe these insertion modifications can be refactored to be more DRY eventually.

function assignResults(node: StatementTuple[] | ASTNode, collect: (node: ASTNode) => ASTNode): void

  // TODO: unify this with the `exp` switch

  switch node.type

    when "BlockStatement"

      if node.expressions.length

        assignResults(node.expressions.-1, collect)

      else

        node.expressions.push(["", collect("void 0"), ";"])

        updateParentPointers node

      return

    when "WhenClause", "DefaultClause", "PatternClause"

      assignResults(node.block, collect)

      return

  [, exp, semi] .= node

  return if semi?.type is "SemicolonDelimiter"

  return if isExit exp

  exp = exp as ASTNodeObject

  outer := exp

  if exp.type is "LabelledStatement"

    exp = exp.statement

  switch exp.type

      return

    when "Declaration"

      value := if exp.bindings?.#

        patternAsValue(exp.bindings.-1.pattern)

      else

        "void 0"

      exp.children.push([

        "", [";", collect(value) ]

      ])

      updateParentPointers exp

      return

    when "FunctionExpression"

      if exp.id

        exp.children.push [

          "", [";", collect(exp.id)]

        ]

        updateParentPointers exp

        return

      /* c8 ignore next 3 */

      // This is currently never hit because anonymous FunctionExpressions are already wrapped in parens by this point

      // Add return in normal way for functions without ids

      break

    when "ForStatement", "IterationStatement", "DoStatement", "ComptimeStatement"

      wrapIterationReturningResults exp, collect

      return

    when "BlockStatement"

      assignResults(exp.expressions.-1, collect)

      return

    when "IfStatement"

      // if block

      assignResults(exp.then, collect)

      // else block

      if exp.else

        assignResults(exp.else.block, collect)

      else // Add else block pushing undefined if no else block

        // Ensure then block is properly terminated for added else block

        braceBlock exp.then

        exp.children.push([" else {", collect("void 0"), "}"])

        updateParentPointers exp

      return

    when "PatternMatchingStatement"

      assignResults(exp.children[0], collect)

      return

    when "SwitchStatement"

      // insert a results.push in each case block

      for each clause of exp.caseBlock.clauses

        assignResults clause, collect

      return

    when "TryStatement"

      // NOTE: CoffeeScript doesn't add a push to an empty catch block but does add if there is any statement in the catch block

      // we always add a push to the catch block

      // NOTE: does not insert a push in the finally block

      for each block of exp.blocks

        assignResults block, collect

      return

    when "PipelineExpression"

      // Child 0 is whitespace; if child 1 is exiting statement, don't return it

      // At statement level, pipeline generates semicolons between statements

      // Return the last one

      semi := exp.children.lastIndexOf ";"

      if 0 <= semi < exp.children# - 1

        exp.children[semi+1..] = [collect exp.children[semi+1..]]

        updateParentPointers exp

        return

  // Don't push if there's a trailing semicolon

  // Insert push wrapping expression

  parent := node[1].parent

  node[1] = collect(node[1])

  updateParentPointers parent if parent?

// [indent, statement, semicolon]

function insertReturn(node: ASTNode): void

  // TODO: unify this with the `exp` switch

  switch node.type

    when "BlockStatement"

      if node.expressions#

        return if node.expressions.some ([, exp]) => isExit exp

        last := node.expressions[node.expressions.length - 1]

        insertReturn(last)

      else

        // NOTE: Kind of hacky but I'm too much of a coward to make `->` add an implicit return

        if node.parent?.type is like "CatchClause", "WhenClause"

          node.expressions.push ["", wrapWithReturn(undefined, node)]

      return

    // NOTE: "CaseClause"s don't get a return statement inserted

    when "WhenClause"

      // Remove inserted `break;` if it hasn't already been removed

      if node.break

        breakIndex := node.children.indexOf node.break

        assert.notEqual breakIndex, -1, "Could not find break in when clause"

        node.children.splice breakIndex, 1

        node.break = undefined

      // Then try to add implicit return

      insertReturn node.block

      unless isExit node.block

        comment := hasTrailingComment node.block.expressions

        node.block.expressions.push [

          wrapWithReturn undefined, node, not comment

        ]

      return

    when "DefaultClause"

      insertReturn(node.block)

      return

  [, exp, semi] .= node

  return if semi?.type is "SemicolonDelimiter"

  outer := exp

  if exp.type is "LabelledStatement"

    exp = exp.statement

  switch exp.type

      return

    when "Declaration"

      value := if exp.bindings?.#

        [" ", patternAsValue(exp.bindings.-1.pattern)]

      else

        [] as ASTNode

      parent := outer.parent as BlockStatement?

      index := findChildIndex parent?.expressions, outer

      assert.notEqual index, -1, "Could not find declaration in parent"

      parent!.expressions.splice index+1, 0, ["",

        type: "ReturnStatement"

        expression: value

        children: [

          ";" unless parent!.expressions[index][2] is ";"

          "return"

          value

        ]

        parent: exp

      ]

      braceBlock parent!

      return

    when "FunctionExpression"

      // Add return after function declaration if it has an id to not interfere with hoisting

      if exp.id

        parent := outer.parent as BlockStatement?

        index := findChildIndex parent?.expressions, outer

        assert.notEqual index, -1, "Could not find function declaration in parent"

        parent!.expressions.splice index+1, 0, ["",

          wrapWithReturn exp.id, exp, true

        ]

        braceBlock parent!

        return

      /* c8 ignore next 3 */

      // This is currently never hit because anonymous FunctionExpressions are already wrapped in parens by this point

      // Add return in normal way for functions without ids

      break

    when "ForStatement", "IterationStatement", "DoStatement", "ComptimeStatement"

      wrapIterationReturningResults exp

      return

    when "BlockStatement"

      insertReturn(exp.expressions[exp.expressions.length - 1])

      return

    when "IfStatement"

      // if block

      insertReturn(exp.then)

      // else block

      if (exp.else) insertReturn(exp.else.block)

      // Add explicit return after if block if no else block

      else exp.children.push ["",

        // NOTE: add a prefixed semicolon because the if block may not be braced

        wrapWithReturn undefined, exp, true

      ]

      return

    when "PatternMatchingStatement"

      insertReturn exp.children[0]

      return

    when "SwitchStatement"

      // insert a return in each when/else/default block

      // case blocks don't get implicit returns

      for each clause of exp.caseBlock.clauses

        insertReturn clause

      return

    when "TryStatement"

      for each block of exp.blocks

        insertReturn block

      // NOTE: do not insert a return in the finally block

      return

    when "PipelineExpression"

      // Child 0 is whitespace; if child 1 is exiting statement, don't return it

      return if exp.children.1?.type is like "ReturnStatement", "ThrowStatement"

      // At statement level, pipeline generates semicolons between statements

      // Return the last one

      semi := exp.children.lastIndexOf ";"

      if 0 <= semi < exp.children# - 1

        exp.children[semi+1..] = [wrapWithReturn exp.children[semi+1..]]

        return

  // Don't add return if there's a trailing semicolon

  // Insert return after indentation and before expression

  node[1] = wrapWithReturn node[1]

// Process `break with` and `continue with` within a loop statement

// that already has a resultsRef attribute.

// Returns whether the resultsRef might be modified, so should use let.

function processBreakContinueWith(statement: IterationStatement | ForStatement): boolean

  changed .= false

  for control of gatherRecursiveWithinFunction(statement.block,

    .type is "BreakStatement" or .type is "ContinueStatement"

  )

    // break with <expr> overwrites the results of the loop

    // continue with <expr> appends to the results of the loop

    if control.with

      if control.label

        continue unless statement.parent is like {

          type: "LabelledStatement"

          label: { name: ^control.label.name }

        }

      else

        // Verify there wasn't another loop or switch in between

        {ancestor} := findAncestor control,

          (s: ASTNodeObject): s is IterationStatement | ForStatement | SwitchStatement => (or)

            s is statement

            s.type is "IterationStatement"

            s.type is "ForStatement"

            s.type is "SwitchStatement" and control.type is "BreakStatement"

        continue unless ancestor is statement

      control.children.unshift

        if control.type is "BreakStatement"

          changed = true

          [statement.resultsRef, ' =', control.with, ';']

        else // control.type is "ContinueStatement"

          [statement.resultsRef, '.push(', trimFirstSpace(control.with), ');']

      updateParentPointers control.with, control

      // Remove warning associated with break/continue with

      i := control.children.findIndex ?.type is "Error"

      control.children.splice i, 1 if i >= 0

      // Brace containing block now that it has multiple statements

      block := control.parent

      unless block?.type is "BlockStatement"

      braceBlock block

  changed

function wrapIterationReturningResults(

  statement: IterationFamily,

  collect?: (node: ASTNode) => ASTNode

): void

  if statement.type is "DoStatement" or statement.type is "ComptimeStatement"

    let results: ASTNode

    if statement.type is "ComptimeStatement"

      // Always wrap comptime in IIFE

      insertReturn statement.block

      expression := expressionizeComptime statement

      replaceNode statement, expression

      parent := expression.parent as BlockStatement?

      results = parent?.expressions?[findChildIndex parent?.expressions, expression]

      assert.equal (results as StatementTuple)?[1], expression,

        "comptime statement found outside statement tuple"

    else

      results = statement.block

    if collect

      assignResults results, collect

    else

      insertReturn results

    return

  // This may have already been called by `braceBlock`

  // to implement `implicitlyReturned`

  return if statement.resultsRef?

  // Inherit parent's resultsRef if requested

  if statement.resultsParent

    { ancestor } := findAncestor statement,

      .type is "ForStatement" or .type is "IterationStatement"

      isFunction

    unless ancestor

      statement.children.unshift

        type: "Error"

        message: "Could not find ancestor of spread iteration"

      return

    resultsRef := statement.resultsRef = ancestor.resultsRef

    iterationDefaultBody statement

    { block } := statement

    unless block.empty

      assignResults block, (node) => [ resultsRef, ".push(", node, ")" ]

    return

  resultsRef := statement.resultsRef ?= makeRef "results"

  declaration := iterationDeclaration statement

  { ancestor, child } := findAncestor statement, .type is "BlockStatement"

  assert.notNull ancestor, `Could not find block containing ${statement.type}`

  index := findChildIndex ancestor.expressions, child

  assert.notEqual index, -1, `Could not find ${statement.type} in containing block`

  iterationTuple := ancestor.expressions[index]

  ancestor.expressions.splice index, 0, [iterationTuple[0], declaration, ";"]

  iterationTuple[0] = '' // steal indentation from loop

  braceBlock ancestor

  if collect

    statement.children.push collect(resultsRef)

  else

    statement.children.push(";return ", resultsRef, ";")

// Creates and returns a declaration for the results of a loop,

// so that the caller can add it to the containing block.

// Also wraps the body to collect the loop results.

function iterationDeclaration(statement: IterationStatement | ForStatement)

  { resultsRef, block } := statement

  reduction := statement.type is "ForStatement" and statement.reduction

  decl: "const" | "let" .= reduction ? "let" : "const"

  if statement.type is "IterationStatement" or statement.type is "ForStatement"

    if processBreakContinueWith statement

      decl = "let"

  // Check for infinite loops with only `break with`, no plain `break`

  breakWithOnly := (and)

    decl is "let"

    isLoopStatement statement

    gatherRecursive(block,

      (s): s is BreakStatement => s.type is "BreakStatement" and not s.with,

      (s) => isFunction(s) or s.type is "IterationStatement")# is 0

  declaration: Declaration := {

    type: "Declaration"

    children: [decl, " ", resultsRef]

    decl

    names: []

    bindings: []

  }

  if reduction

    declaration.children.push "=" +

      switch reduction.subtype

        when "some" then "false"

        when "every" then "true"

        when "first" then "undefined"

        when "min" then "Infinity"

        when "max" then "-Infinity"

        when "product" then "1"

        when "join" then '""'

        when "concat" then "[]"

        else "0"

  else if statement.object

    declaration.children.push "={}"

  else

    // Assign [] directly only in const case, so TypeScript can better infer

    if decl is "const"

      declaration.children.push "=[]"

    else // decl is "let"