10756119626

Committed 08 Sep 2024 01:52AM UTC coverage: 91.315% (-0.09%) from 91.402%

Build # 10756119626

Build Type

Pull #1394

github

Committed by

web-flow

Commit Message

Merge 4e19e145a into 06548cbaf

Pull Request Pull Request #1394: `for*`, `loop*`, `while*` generator expressions

Run Details

2878 of 3134 branches covered (91.83%)

Branch coverage included in aggregate %.

48 of 66 new or added lines in 4 files covered. (72.73%)

24 existing lines in 3 files now uncovered.

16006 of 17546 relevant lines covered (91.22%)

18696.62 hits per line

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

95.16

/source/parser/util.civet

import type {
  ASTLeaf
  ASTNode
  ASTNodeBase
  ASTNodeObject
  ASTNodeParent
  Children
  FunctionNode
  IsParent
  IsToken
  Literal
  StatementNode
  TypeSuffix
  ReturnTypeAnnotation
  StatementTuple
} from ./types.civet

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

assert := {
  equal(a: unknown, b: unknown, msg: string): void
    /* c8 ignore next */
    throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`) if a !== b
}

/**
 * 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 IsParent
  node? and node.children?

function isToken(node: ASTNode): node is 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"
  "LabeledStatement"
  "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

/**
 * 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"
      (and)
        isExit node.then
        isExit node.else?.block
    when "BlockStatement"
      // [1] extracts statement from [indent, statement, delim]
      node.expressions.some (s) => isExit s[1]
    // Infinite loops
    when "IterationStatement"
      (and)
        node.condition?.type is "ParenthesizedExpression"
        node.condition.expression?.type is "Literal"
        node.condition.expression?.raw is "true"
        gatherRecursiveWithinFunction(node.block,
          .type is "BreakStatement").length is 0
        // TODO: Distinguish between break of this loop vs. break of inner loops
    else
      false

/**
 * 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

/**
 * 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(target: ASTNode, c: string): ASTNode
  return target unless target?

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

    target.map (e, i) =>
      if i is 0
        insertTrimmingSpace(e, c)
      else
        e
  else if isParent target
    {
      ...target
      children: insertTrimmingSpace(target.children, c)
    }
  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(target: ASTNode): ASTNode
  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)
  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)
  let { raw } = literal
  switch (raw) {
    case "null": return null
    case "true": return true
    case "false": return false
  }
  if (
    (raw.startsWith('"') and raw.endsWith('"')) ||
    (raw.startsWith("'") and raw.endsWith("'"))
  ) {
    return raw.slice(1, -1)
  }
  const numeric = literal.children.find(
    (child) => child.type is "NumericLiteral"
  )
  if (numeric) {
    raw = raw.replace(/_/g, "")
    const { token } = numeric
    if (token.endsWith("n")) {
      return BigInt(raw.slice(0, -1))
    } else if (token.match(/[\.eE]/)) {
      return parseFloat(raw)
    } else if (token.startsWith("0")) {
      switch (token.charAt(1).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)
  }
  throw new Error("Unrecognized literal " + JSON.stringify(literal))

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

/**
* Copy an AST node deeply, including children.
* Ref nodes maintain identity
*/
function deepCopy(node: ASTNode): ASTNode
  if (node == null) return node
  if (typeof node !== "object") return node

  if Array.isArray node
    return node.map deepCopy

  if node?.type is "Ref" return node

  // Use from entries to clone objects
  // map the values to clone the children
  return Object.fromEntries(
    Object.entries(node).map [key, value] =>
      return [key, deepCopy(value)]

  ) as any

/**
* 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"
  "CallExpression"
  "Identifier"
  "JSXElement"
  "JSXFragment"
  "Literal"
  "NewExpression"
  "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)
  if isASTNodeObject expression
    return expression if expression.parenthesized
    return expression if skipParens.has expression.type
    return expression if expression.type is "MemberExpression" and
      not startsWithPredicate(expression, .type is "ObjectExpression")

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

/**
 * 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: ASTNode, child: ASTNode, del, ...replacements)
  children := node?.children ?? node
  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 as ASTNodeBase).type is "AssertsType"
    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 and "("
    // TODO: avoid parens if unnecessary
    "undefined | "
    parenthesizeType insertTrimmingSpace suffix.t, ""
    wrap and ")"
  ]

const typeNeedsNoParens = new Set [
  "IdentifierType"
  "ImportType"
  "LiteralType"
  "TupleType"
  "ParenthesizedType"
  "UnaryType"
]
/**
 * Parenthesize type if it might need it in some contexts.
 */
function parenthesizeType(type: ASTNode)
  return type if typeNeedsNoParens.has type.type
  ["(", type, ")"]

/**
 * Wrap an expression in an IIFE, adding async/await if expression
 * uses await, or just adding async if specified.
 * Returns an Array suitable for `children`.
 */
function wrapIIFE(expressions: StatementTuple[], asyncFlag?: boolean, generator?: ASTNode): ASTNode
  let prefix

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

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

  parameters :=
    type: "Parameters"
    children: ["()"]
    names: []

  signature :=
    modifier:
      async: !!async.length
      generator: !!generator
    returnType: undefined

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

  exp := makeNode
    type: "CallExpression"
    children: [ makeLeftHandSideExpression(fn), "()" ]

  if prefix
    return makeLeftHandSideExpression [prefix, exp]

  return exp

function wrapWithReturn(expression?: ASTNode): ASTNode
  const children = expression ? ["return ", expression] : ["return"]

  return makeNode {
    type: "ReturnStatement",
    children,
    expression,
    parent: 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
  clone
  convertOptionalType
  deepCopy
  flatJoin
  getTrimmingSpace
  hasAwait
  hasImportDeclaration
  hasYield
  inplaceInsertTrimmingSpace
  inplacePrepend
  insertTrimmingSpace
  isASTNodeObject
  isComma
  isEmptyBareBlock
  isExit
  isFunction
  isStatement
  isToken
  isWhitespaceOrEmpty
  literalValue
  makeLeftHandSideExpression
  makeNode
  maybeWrap
  maybeUnwrap
  parenthesizeType
  prepend
  removeHoistDecs
  removeParentPointers
  skipIfOnlyWS
  startsWith
  startsWithPredicate
  trimFirstSpace
  updateParentPointers
  wrapIIFE
  wrapWithReturn
}

DanielXMoore / Civet / 10756119626

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