21042909916

Committed 15 Jan 2026 07:01PM UTC coverage: 91.616% (+0.01%) from 91.606%

Build # 21042909916

Build Type

Pull #1838

github

Committed by

web-flow

Commit Message

Merge 0420daaf1 into 5f9b32981

Pull Request Pull Request #1838: Infer partial object/array types from initializers

Run Details

3775 of 4114 branches covered (91.76%)

Branch coverage included in aggregate %.

62 of 62 new or added lines in 3 files covered. (100.0%)

1 existing line in 1 file now uncovered.

19174 of 20935 relevant lines covered (91.59%)

17395.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.01

/source/parser/util.civet

import type {
  ASTLeaf
  ASTNode
  ASTNodeObject
  ASTNodeParent
  ASTString
  Children
  FunctionNode
  FunctionSignature
  Identifier
  IsParent
  IsToken
  IterationStatement
  Literal
  Parameter
  ParametersNode
  Parent
  RegularExpressionLiteral
  ReturnTypeAnnotation
  StatementNode
  StatementTuple
  TemplateLiteral
  TypeNode
  TypeSuffix
} from ./types.civet

import {
  gatherRecursiveWithinFunction
  type Predicate
} from ./traversal.civet

// Types need to be upfront to allow for TypeScript `asserts`
assert: {
  equal(a: unknown, b: unknown, msg: string): asserts a is b
  notEqual(a: unknown, b: unknown, msg: string): void
  notNull<T>(a: T, msg: string): asserts a is NonNullable<T>
} := {
  equal(a, b, msg): void
    /* c8 ignore next */
    throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`) if a !== b
  notEqual(a, b, msg): void
    /* c8 ignore next */
    throw new Error(`Assertion failed [${msg}]: ${a} === ${b}`) if a === b
  notNull(a, msg)
    /* c8 ignore next */
    throw new Error(`Assertion failed [${msg}]: got null`) unless a?
}

/**
 * Adds parent pointers to all nodes in the AST. Elements within
 * arrays of nodes receive the closest non-array object parent.
 */
function addParentPointers(node: ASTNode, parent?: ASTNodeObject): void
  if (not node?) return
  if (typeof node !== "object") return

  // NOTE: Arrays are transparent and skipped when traversing via parent
  if Array.isArray(node)
    for child of node
      addParentPointers(child, parent)
    return

  node = node as ASTNodeObject
  node.parent = parent if parent?
  if node.children
    for each child of node.children
      addParentPointers(child, node)

/**
 * Clone an AST node including children (removing parent pointes)
 * This gives refs new identities which may not be what we want.
 *
 * TODO: preserve ref identities
 */
function clone(node: ASTNode)
  removeParentPointers(node)
  return deepCopy(node)

function removeParentPointers(node: ASTNode): void
  return unless node? <? "object"

  // NOTE: Arrays are transparent and skipped when traversing via parent
  if Array.isArray node
    for child of node
      removeParentPointers child
    return

  node.parent = null
  if node.children
    for child of node.children
      removeParentPointers child

// If node is not an ASTNodeObject, wrap it in a special "Wrapper" node
// so that it can have a parent (second argument).
function maybeWrap(node: ASTNode, parent: ASTNodeObject?): ASTNodeObject
  unless isASTNodeObject node
    updateParentPointers node = {
      type: 'Wrapper'
      children: [ node ]
      parent
    }
  node

// Unwrap "Wrapper" node if there is one.
// You should call `updateParentPointers` after this gets assigned somewhere.
function maybeUnwrap(node: ASTNode): ASTNode
  if node?.type is "Wrapper"
    node.children[0]
  else
    node

function isASTNodeObject(node: ASTNode): node is ASTNodeObject
  (and)
    node <? "object"
    node?
    not Array.isArray node

function isParent(node: ASTNode): node is ASTNode & IsParent
  node? and node.children?

function isToken(node: ASTNode): node is ASTNode & IsToken
  node? and node.token?

function isEmptyBareBlock(node: ASTNode): boolean
  if (node?.type !== "BlockStatement") return false
  { bare, expressions } := node
  return bare and
    expressions is like [], [ [, {type: "EmptyStatement"}, ...] ]

function isFunction(node: ASTNode): node is FunctionNode
  if { type } := node
    return (or)
      type is "FunctionExpression"
      type is "ArrowFunction"
      type is "MethodDefinition"

  return false

// Keep this in sync with StatementNode in types.civet
statementTypes := new Set [
  "BlockStatement"
  "BreakStatement"
  "ComptimeStatement"
  "ContinueStatement"
  "DebuggerStatement"
  "Declaration"
  "DoStatement"
  "ForStatement"
  "IfStatement"
  "IterationStatement"
  "LabelledStatement"
  "ReturnStatement"
  "SwitchStatement"
  "ThrowStatement"
  "TryStatement"
]
function isStatement(node: ASTNode): node is StatementNode
  (and)
    isASTNodeObject node
    node.type?  // forbid leaf
    statementTypes.has node.type

function isWhitespaceOrEmpty(node): boolean
  if (!node) return true
  if (node.type is "Ref") return false
  if (node.token) return /^\s*$/.test(node.token)
  if (node.children) node = node.children
  if (!node.length) return true
  if (typeof node is "string") return /^\s*$/.test(node)
  if (Array.isArray(node)) return node.every(isWhitespaceOrEmpty)
  return false

// Returns leading space as a string, or undefined if none
function firstNonSpace(node: ASTNode): ASTNode
  return unless node?
  if Array.isArray node
    for each child of node
      if first := firstNonSpace child
        return first
    return undefined
  else if isParent node
    if first := firstNonSpace node.children
      return first
    else
      return node
  else if isToken node
    return if node.token is like /^[ \t]*$/
  else if node <? "string"
    return if node is like /^[ \t]*$/
  node

/**
 * Does this statement force exit from normal flow, or loop forever,
 * implying that the line after this one can never execute?
 */
function isExit(node: ASTNode): boolean
  return false unless node?
  switch node.type
    // Exit from normal flow
    when "ReturnStatement", "ThrowStatement", "BreakStatement", "ContinueStatement"
      true
    // if checks then and else clause
    when "IfStatement"
      (or)
        // `insertReturn` for IfStatement adds a return to children
        // when there's no else block
        node.children.-1?.type is "ReturnStatement"
        (node.children.-1 as StatementTuple)?[1]?.type is "ReturnStatement"
        (and)
          isExit node.then
          isExit node.else?.block
    when "PatternMatchingStatement"
      isExit node.children[0][1]
    when "SwitchStatement"
      (and)
        // Every clause should exit, or continue to next clause
        for every clause of node.caseBlock.clauses
          if clause.type is like "CaseClause", "WhenClause", "DefaultClause"
            // `break` might jump to end of switch, so don't consider an exit
            not (clause.type is "WhenClause" and clause.break) and
            not gatherRecursiveWithinFunction(clause.block, .type is "BreakStatement")#
          else
            isExit clause.block
        // Ensure exhaustive by requiring an else/default clause
        for some clause, i of node.caseBlock.clauses
          clause.type is "DefaultClause" and
          // Require default clause to exit or continue to next clause
          // (checked above) and eventually reach an exiting clause
          for some later of node.caseBlock.clauses[i..]
            later.type is like "CaseClause", "WhenClause", "DefaultClause" and
            isExit later.block
    when "TryStatement"
      // Require all non-finally blocks to exit
      node.blocks.every isExit
    when "BlockStatement"
      // [1] extracts statement from [indent, statement, delim]
      node.expressions.some (s) => isExit s[1]
    // Infinite loops
    when "IterationStatement"
      (and)
        isLoopStatement node
        gatherRecursiveWithinFunction(node.block,
          .type is "BreakStatement").length is 0
        // TODO: Distinguish between break of this loop vs. break of inner loops
    else
      false

// Is this a `loop` statement, or equivalent `while(true)`?
function isLoopStatement(node: ASTNodeObject): node is IterationStatement
  (and)
    node.type is "IterationStatement"
    node.condition?.type is "ParenthesizedExpression"
    node.condition.expression?.type is "Literal"
    node.condition.expression?.raw is "true"

/**
 * Detects Comma, CommaDelimiter, and ParameterElementDelimiter
 * with an explicit comma, as should be at the top level of
 * a "Call" node's `args` array.
 * Returns the node whose `token` is ",", or else undefined.
 */
function isComma(node: ASTNode): (ASTLeaf & { token: "," }) | undefined
  if node?.token is ","
    node
  else if Array.isArray(node) and node.-1?.token is ","
    node.-1

function stripTrailingImplicitComma(children: ASTNode[])
  last := children.-1
  if isComma(last) and last.implicit
    children[...-1]
  else
    children

function hasTrailingComment(node: ASTNode): boolean
  return false unless node?
  return true if node.type is "Comment"
  if Array.isArray node
    return hasTrailingComment node.-1
  if "children" in node
    return hasTrailingComment (node.children as Children).-1
  false

/**
 * Trims the first single space from the spacing array or node's children if present
 * Inserts string `c` in the first position.
 * maintains $loc for source maps
 */
function insertTrimmingSpace<T extends ASTNode>(target: T, c: string): T
  return target unless target?

  if Array.isArray target
    return c if target.length is 0

    for each e, i of target
      if i is 0
        insertTrimmingSpace(e, c)
      else
        e
  else if isParent target
    oldChildren := target.children
    target = {
      ...target
      children: insertTrimmingSpace target.children, c
    }
    // Preserve aliased properties
    for key in target
      i := oldChildren.indexOf target[key]
      if i >= 0
        target[key] = target.children[i]
    target
  else if isToken target
    {
      ...target
      token: target.token.replace(/^ ?/, c)
    }
  else if target <? "string"
    target.replace(/^ ?/, c)
  else
    target

/**
 * Trims the first single space from the spacing array or node's children if present
 * maintains $loc for source maps
 */
function trimFirstSpace<T extends ASTNode>(target: T): T
  insertTrimmingSpace target, ""

function inplaceInsertTrimmingSpace(target: ASTNode, c: string): void
  return target unless target?
  if Array.isArray target
    inplaceInsertTrimmingSpace target[0], c
  else if isParent target
    inplaceInsertTrimmingSpace target.children, c
  else if isToken target
    target.token = target.token.replace(/^ ?/, c)

// Returns leading space as a string, or undefined if none
function getTrimmingSpace(target: ASTNode): string?
  return unless target?
  if Array.isArray target
    getTrimmingSpace target[0]
  else if isParent target
    getTrimmingSpace target.children[0]
  else if isToken target
    target.token.match(/^ ?/)![0]

// Glom content e.g. whitespace into AST nodes
// NOTE: This can get weird if we depend on the specific location of children
function prepend(prefix: ASTNode, node: ASTNode): ASTNode
  return node if not prefix or prefix is like []
  if Array.isArray node
    [prefix, ...node]
  else if isParent node
    {
      ...node
      children: [prefix, ...node.children]
    } as typeof node
  // NOTE: Not glomming into an AST leaf; would need to flatten prefix
  else
    [prefix, node]

function append(node: ASTNode, suffix: ASTNode): ASTNode
  return node if not suffix or suffix is like []
  if Array.isArray node
    [...node, suffix]
  else if isParent node
    {
      ...node
      children: [...node.children, suffix]
    } as typeof node
  // NOTE: Not glomming into an AST leaf; would need to flatten suffix
  else
    [node, suffix]

function inplacePrepend(prefix: ASTNode, node: ASTNode): void
  return unless prefix
  return if Array.isArray(prefix) and not prefix.length
  if Array.isArray node
    node.unshift prefix
  else if isParent node
    node.children.unshift prefix
  else
    throw new Error "Can't prepend to a leaf node"

// Convert (non-Template) Literal to actual JavaScript value
function literalValue(literal: Literal)
  { raw } .= literal
  switch raw
    case "null": return null
    case "true": return true
    case "false": return false
  switch literal.subtype
    when "StringLiteral"
      assert.equal
        (or)
          raw.startsWith('"') and raw.endsWith('"')
          raw.startsWith("'") and raw.endsWith("'")
        true, "String literal should begin and end in single or double quotes"
      return raw[1...-1]
    when "NumericLiteral"
      raw = raw.replace(/_/g, "")
      if raw.endsWith("n")
        return BigInt raw[0...-1]
      else if raw.match(/[\.eE]/)
        return parseFloat(raw)
      else if [ , base ] := raw.match(/^[+-]?0(.)/)
        switch base.toLowerCase()
          case "x": return parseInt(raw.replace(/0[xX]/, ""), 16)
          case "b": return parseInt(raw.replace(/0[bB]/, ""), 2)
          case "o": return parseInt(raw.replace(/0[oO]/, ""), 8)
      return parseInt(raw, 10)
    else
      throw new Error("Unrecognized literal " + JSON.stringify(literal))

/** TypeScript type for given literal */
function literalType(literal: Literal | RegularExpressionLiteral | TemplateLiteral): TypeNode
  let t: ASTString
  switch literal.type
    when "RegularExpressionLiteral"
      t = "RegExp"
    when "TemplateLiteral"
      t = "string"
    when "Literal"
      switch literal.subtype
        when "NullLiteral"
          t = "null"
        when "BooleanLiteral"
          t = "boolean"
        when "NumericLiteral"
          if literal.raw.endsWith 'n'
            t = "bigint"
          else
            t = "number"
        when "StringLiteral"
          t = "string"
        else
          throw new Error `unknown literal subtype ${literal.subtype}`
    else
      throw new Error `unknown literal type ${literal.type}`
  {}
    type: "TypeLiteral"
    t
    children: [t]

/**
 * Attempt to infer TypeScript type suffix from expression,
 * similar to TypeScript's inferred type for `x` in `let x = expression`.
 * Returns undefined if the expression is too complicated,
 * or something TypeScript wouldn't infer like `null` or `undefined`.
 */
function typeOfExpression(expression: ASTNode): TypeNode?
  let t: TypeNode
  return unless isASTNodeObject expression
  switch expression.type
    when "Literal"
      switch expression.subtype
        when "NullLiteral"
          // `let x = null` doesn't infer type for `x`
          return
        else
          t = literalType expression
    when "RegularExpressionLiteral", "TemplateLiteral"
      t = literalType expression
    when "Identifier"
      // `let x = undefined` doesn't infer type for `x`
      return if expression.name is "undefined"
      continue switch
    when "MemberExpression"
      t = {}
        type: "TypeTypeof"
        children: ["typeof ", expression]
        expression
    else
      // TypeScript's typeof doesn't support arguments
      // beyond identifiers and member expressions
      return
  t

function typeSuffixForExpression(expression: ASTNode): TypeSuffix?
  t := typeOfExpression expression
  return unless t?
  {
    type: "TypeSuffix"
    ts: true
    t
    children: [": ", t]
  }

function makeNumericLiteral(n: number): Literal
  s := n.toString()
  type: "Literal"
  subtype: "NumericLiteral"
  raw: s
  children: [
    {
      type: "NumericLiteral"
      token: s
    } as NumericLiteral // missing $loc
  ]

/**
* Detect whether the first nontrivial string/token matches a given regular
* expression. You probably want the RegExp to start with `^`.
*/
function startsWith(target: ASTNode, value: RegExp)
  if (!target) return
  if Array.isArray target
    let i = 0
    let l = target.length
    while i < l
      const t = target[i]
      break if t and (t.length or t.token or t.children)
      i++
    if i < l
      return startsWith target[i], value
  if (typeof target is "string") return value.test target
  if (target.children) return startsWith target.children, value
  if (target.token) return value.test target.token

function startsWithPredicate<T extends ASTNodeObject>(node: ASTNode, predicate: Predicate<T>, skip = isWhitespaceOrEmpty): T | undefined
  return undefined if not node? or node <? "string"

  if Array.isArray node
    for each child of node
      continue if skip child
      return startsWithPredicate child, predicate
    return

  return node if predicate node
  return unless node.children?
  startsWithPredicate node.children, predicate

/**
 * Does this expression have an `await` in it and thus needs to be `async`?
 * Skips over nested functions, which have their own async behavior.
 */
function hasAwait(exp: ASTNode)
  gatherRecursiveWithinFunction(exp, .type is "Await").length > 0

function hasYield(exp: ASTNode)
  gatherRecursiveWithinFunction(exp, .type is "Yield").length > 0

function hasImportDeclaration(exp: ASTNode)
  gatherRecursiveWithinFunction(exp, .type is "ImportDeclaration").length > 0

function hasExportDeclaration(exp: ASTNode)
  gatherRecursiveWithinFunction(exp, .type is "ExportDeclaration").length > 0

/**
* Copy an AST node deeply, including children.
* Ref nodes maintain identity
* Preserves aliasing
*/
function deepCopy<T extends ASTNode>(root: T): T
  copied := new Map<ASTNode, ASTNode>
  return recurse(root) as T

  function recurse(node: ASTNode): ASTNode
    return node unless node? <? "object"

    unless copied.has node
      if Array.isArray node
        array: ASTNode[] := new Array node#
        copied.set node, array
        for each item, i of node
          array[i] = recurse item
      else if node?.type is "Ref"
        copied.set node, node
      else
        obj: any := {}
        copied.set node, obj
        for key in node
          value := (node as any)[key]
          if key is "parent"
            // If parent is within deep copy, use that
            // Otherwise, don't copy to avoid copying outside subtree
            obj.parent = copied.get(value) ?? value
          else
            obj[key] = recurse value

    copied.get node

/**
 * Replace this node with another, by modifying its parent's children.
 */
function replaceNode(node: ASTNode, newNode: ASTNode, parent?: ASTNodeParent): void
  parent ??= (node as ASTNodeObject?)?.parent
  unless parent?
    throw new Error "replaceNode failed: node has no parent"

  function recurse(children: ASTNode[]): boolean
    for each child, i of children
      if child is node
        children[i] = newNode
        return true
      else if Array.isArray child
        return true if recurse child
    return false

  unless recurse parent.children
    throw new Error "replaceNode failed: didn't find child node in parent"

  // Adjust 'expression' etc. alias pointers
  for key, value in parent
    if value is node
      parent[key] = newNode

  if isASTNodeObject newNode
    newNode.parent = parent
  // Don't destroy node's parent, as we often include it within newNode
  //node.parent = undefined

/**
 * Replace all nodes that match predicate with replacer(node)
 */
function replaceNodes(root, predicate, replacer)
  return root unless root?

  array := Array.isArray(root) ? root : root.children

  unless array
    if predicate root
      return replacer root, root
    else
      return root

  for each node, i of array
    return unless node?
    if predicate node
      array[i] = replacer node, root
    else
      replaceNodes node, predicate, replacer

  return root

/**
* When cloning subtrees sometimes we need to remove hoistDecs
*/
function removeHoistDecs(node: ASTNode): void
  if (not node?) return
  if (typeof node !== "object") return

  if "hoistDec" in node
    node.hoistDec = undefined

  // NOTE: Arrays are transparent and skipped when traversing via parent
  if Array.isArray(node)
    for child of node
      removeHoistDecs(child)
    return

  if node.children
    for child of node.children
      removeHoistDecs(child)

skipParens := new Set [
  "AmpersandRef"
  "ArrayExpression"
  "CallExpression"
  "Identifier"
  "JSXElement"
  "JSXFragment"
  "Literal"
  "ParenthesizedExpression"
  "Ref"
  "Placeholder"
  "StatementExpression" // wrapIIFE
]

/**
 * Convert general ExtendedExpression into LeftHandSideExpression.
 * More generally wrap in parentheses if necessary.
 * (Consider renaming and making parentheses depend on context.)
 */
function makeLeftHandSideExpression(expression: ASTNode)
  while [ item ] := expression
    expression = item
  if isASTNodeObject expression
    return expression if expression.token
    return expression if expression.parenthesized
    return expression if skipParens.has expression.type
    // `new Foo` and `new Foo.Bar` need parenthesization;
    // `new Foo(args)` does not
    return expression if expression.type is "NewExpression" and
      expression.expression.children.some ?.type is "Call"
    return expression if expression.type is "MemberExpression" and
      not startsWithPredicate(expression, .type is "ObjectExpression")
  parenthesizeExpression expression

function parenthesizeExpression(expression: ASTNode)
  makeNode {
    type: "ParenthesizedExpression"
    children: ["(", expression, ")"]
    expression
    implicit: true
  }

// If the expression is not a valid left-hand side for assignment,
// add an Error node to it and return true.
// TOMAYBE: Static semantics https://262.ecma-international.org/#sec-static-semantics-assignmenttargettype
function checkValidLHS(node: ASTNode): boolean
  switch node?.type
    when "UnaryExpression"
      node.children.unshift
        type: "Error"
        message: "Unary expression is not a valid left-hand side"
      return true
    when "CallExpression"
      lastType := node.children.-1?.type
      switch lastType
        when "PropertyAccess", "SliceExpression", "Index"
        else
          node.children.splice -1, 0,
            type: "Error"
            message: `Call expression ending with ${lastType} is not a valid left-hand side`
          return true
    when "Placeholder"
      node.children.unshift
        type: "Error"
        message: `Lone placeholder (${node.subtype}) is not a valid left-hand side`
      return true
  return false

/**
 * Just update parent pointers for the children of a node,
 * recursing into arrays but not objects.  More efficient version of
 * `addParentPointers` when just injecting one new node.
 */
function updateParentPointers(node: ASTNode, parent?: ASTNodeParent, depth = 1): void
  return unless node?
  return unless node <? "object"

  // NOTE: Arrays are transparent and skipped when traversing via parent
  if Array.isArray(node)
    for each child of node
      updateParentPointers(child, parent, depth)
    return

  node = node as ASTNodeObject
  node.parent = parent if parent?
  if depth and isParent node
    for each child of node.children
      updateParentPointers(child, node, depth-1)

function makeNode<T extends ASTNodeObject>(node: T): T
  updateParentPointers node
  node

/**
 * Used to ignore the result of __ if it is only whitespace
 * Useful to preserve spacing around comments
 */
function skipIfOnlyWS(target)
  if (!target) return target
  if (Array.isArray(target)) {
    if (target.length is 1) {
      return skipIfOnlyWS(target[0])
    } else if (target.every((e) => (skipIfOnlyWS(e) is undefined))) {
      return undefined
    }
    return target
  }
  if (target.token != null and target.token.trim() is '') {
    return undefined
  }
  return target

/**
 * Splice child from children/array, similar to Array.prototype.splice,
 * but specifying a child instead of an index.  Throw if child not found.
 */
function spliceChild(node: ASTNodeObject | ASTNode[], child: ASTNode, del: number, ...replacements: ASTNode[])
  children := Array.isArray(node) ? node : node.children
  unless Array.isArray children
    throw new Error "spliceChild: non-array node has no children field"
  index := children.indexOf child
  if index < 0
    throw new Error "spliceChild: child not found"
  children.splice index, del, ...replacements

/**
 * Convert type suffix of `?: T` to `: undefined | T`
 */
function convertOptionalType(suffix: TypeSuffix | ReturnTypeAnnotation): void
  if suffix.t?.type is "TypeAsserts"
    spliceChild suffix, suffix.optional, 1, suffix.optional =
      type: "Error"
      message: "Can't use optional ?: syntax with asserts type"
    return
  spliceChild suffix, suffix.optional, 1, suffix.optional = undefined
  // Return types with | need to be wrapped in parentheses
  wrap := suffix.type is "ReturnTypeAnnotation"
  spliceChild suffix, suffix.t, 1, suffix.t = [
    getTrimmingSpace suffix.t
    wrap ? "(" : undefined
    // TODO: avoid parens if unnecessary
    "undefined | "
    parenthesizeType trimFirstSpace suffix.t
    wrap ? ")" : undefined
  ]

const typeNeedsNoParens = new Set [
  "TypeIdentifier"
  "ImportType"
  "TypeLiteral"
  "TypeTuple"
  "TypeParenthesized"
]
/**
 * Parenthesize type if it might need it in some contexts.
 */
function parenthesizeType(type: ASTNode)
  return type if typeNeedsNoParens.has type.type
  makeNode
    type: "TypeParenthesized"
    ts: true
    children: ["(", type, ")"]

/**
 * Wrap expressions in an IIFE, adding async/await if expressions
 * use await, or just adding async if specified.
 * Uses function* instead of arrow function if given generator star.
 * Returns an Array suitable for `children`.
 */
function wrapIIFE(expressions: StatementTuple[], asyncFlag?: boolean, generatorStar?: ASTNode): ASTNode
  let awaitPrefix: ASTNode?
  generator := generatorStar ? [ generatorStar ] : []

  async := []
  if asyncFlag
    async.push "async "
  else if hasAwait expressions
    async.push "async "
    awaitPrefix =
      type: "Await"
      children: ["await "]

  yieldWrap .= false
  unless generator#
    if hasYield expressions
      generator.push "*"
      yieldWrap = true

  block := makeNode {
    type: "BlockStatement"
    expressions
    children: ["{", expressions, "}"]
    bare: false
    root: false
  }

  parameterList: Parameter[] := []
  parameters: ParametersNode :=
    type: "Parameters"
    children: ["(", parameterList, ")"]
    parameters: parameterList
    names: []

  signature: FunctionSignature := {}
    type: "FunctionSignature"
    modifier:
      async: !!async#
      generator: !!generator#
    parameters
    returnType: undefined
    implicitReturn: true // force implicit return in IIFE
    children:
      generator# ? [ async, "function", generator, parameters ]
                 : [ async, parameters ]

  let fn
  if generator#
    fn = makeNode {
      type: "FunctionExpression"
      signature
      parameters
      returnType: undefined
      async
      block
      generator
      children: [ ...signature.children, block ]
    }
  else
    fn = makeNode {
      type: "ArrowFunction"
      signature
      parameters
      returnType: undefined
      async
      block
      children: [ ...signature.children, "=>", block ]
    }

  children := [ makeLeftHandSideExpression(fn), "()" ]

  if fn.type is "FunctionExpression"
    if gatherRecursiveWithinFunction(block, (is like { token: "this" }))#
      children.splice 1, 0, ".bind(this)"
    if gatherRecursiveWithinFunction(block, (is like { token: "arguments" }))#
      binding: Identifier :=
        type: "Identifier"
        name: "arguments"
        names: ["arguments"]
        children: ["arguments"]
      parameterList.push {}
        type: "Parameter"
        children: [binding]
        names: ["arguments"]
        binding
      children.-1 = "(arguments)"

  exp: ASTNode .= makeNode {
    type: "CallExpression"
    children
  }

  if yieldWrap
    // yield* supports async iterators, so no need to await here
    exp = makeLeftHandSideExpression makeNode
      type: "YieldExpression"
      star: "*"
      expression: exp
      children:
        . type: "Yield"
          children: ["yield"]
        . "*", " "
        . exp
  else if awaitPrefix
    exp = makeLeftHandSideExpression [awaitPrefix, exp]

  return exp

function wrapWithReturn(expression?: ASTNode, parent: Parent = expression?.parent, semi = false): ASTNode
  children := expression ? ["return ", expression] : ["return"]
  children.unshift ";" if semi

  return makeNode {
    type: "ReturnStatement"
    children
    expression
    parent
  }

function flatJoin<T, S>(array: T[][], separator: S): (T | S)[]
  result := []
  for each items, i of array
    result.push separator if i
    result.push ...items
  result

export {
  addParentPointers
  append
  assert
  checkValidLHS
  clone
  convertOptionalType
  deepCopy
  firstNonSpace
  flatJoin
  getTrimmingSpace
  hasAwait
  hasExportDeclaration
  hasImportDeclaration
  hasTrailingComment
  hasYield
  inplaceInsertTrimmingSpace
  inplacePrepend
  insertTrimmingSpace
  isASTNodeObject
  isComma
  isEmptyBareBlock
  isExit
  isFunction
  isLoopStatement
  isStatement
  isToken
  isWhitespaceOrEmpty
  literalValue
  literalType
  typeOfExpression
  typeSuffixForExpression
  makeLeftHandSideExpression
  makeNode
  makeNumericLiteral
  maybeWrap
  maybeUnwrap
  parenthesizeExpression
  parenthesizeType
  prepend
  removeHoistDecs
  removeParentPointers
  replaceNode
  replaceNodes
  skipIfOnlyWS
  spliceChild
  startsWith
  startsWithPredicate
  stripTrailingImplicitComma
  trimFirstSpace
  updateParentPointers
  wrapIIFE
  wrapWithReturn
}

DanielXMoore / Civet / 21042909916

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous