8927536472

Committed 02 May 2024 04:53PM UTC coverage: 92.964% (+0.05%) from 92.917%

Build # 8927536472

Build Type

Pull #1205

github

Committed by

web-flow

Commit Message

Merge 83041298a into f75618cf0

Pull Request Pull Request #1205: ESLint plugin

Run Details

2485 of 2709 branches covered (91.73%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

59 existing lines in 5 files now uncovered.

14454 of 15512 relevant lines covered (93.18%)

17428.3 hits per line

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

96.62

/source/parser/util.civet

import type {
  AmpersandBlockBody
  ArrowFunction
  ASTRef
  ASTLeaf
  ASTNode
  ASTNodeBase
  ASTNodeObject
  ASTNodeParent
  BlockStatement
  IsParent
  IsToken
  Literal
  ParametersNode
  StatementNode
  TypeSuffix
  ReturnTypeAnnotation
  StatementTuple
} from ./types.civet

import {
  braceBlock
} from ./block.civet

import {
  gatherRecursiveWithinFunction
} from ./traversal.civet

import {
  makeRef
} from ./ref.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"}]
    (expressions.length is 0 ||
      (expressions.length is 1 &&
        expressions[0][1]?.type is "EmptyStatement"))

function isFunction(node: ASTNode & { type: unknown, async?: boolean }): boolean
  { type } := node
  (or)
    type is "FunctionExpression"
    type is "ArrowFunction"
    type is "MethodDefinition"
    !!node.async
    // do blocks can be marked async to prevent automatic await

// 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?.-1
    when "BlockStatement"
      // [1] extracts statement from [indent, statement, delim]
      isExit node.expressions.-1?[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}) => 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
    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 unless prefix and prefix.length
  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 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

/**
 * 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)
  gatherRecursiveWithinFunction(exp, ({ type }) => type is "Await").length > 0

function hasYield(exp)
  gatherRecursiveWithinFunction(exp, ({ type }) => type is "Yield").length > 0

function hasImportDeclaration(exp)
  gatherRecursiveWithinFunction(exp, ({ type }) => 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)

function makeAmpersandFunction(rhs: AmpersandBlockBody): ASTNode
  {ref, typeSuffix, body} .= rhs
  unless ref?
    ref = makeRef "$"
    inplacePrepend ref, body
  if body?.type is "ObjectExpression"
    body = makeLeftHandSideExpression body

  parameters := makeNode {
    type: "Parameters"
    children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref]
    names: []
  } as ParametersNode
  expressions := [[' ', body]] satisfies StatementTuple[]
  block := makeNode {
    type: "BlockStatement"
    bare: true
    expressions
    children: [expressions]
    implicitlyReturned: true
  } as BlockStatement

  children := [ parameters, " =>", block ]
  async := hasAwait(body)
  if async
    children.unshift("async ")

  fn := makeNode {
    type: "ArrowFunction"
    signature:
      modifier: {
        async
      }
    children
    ref
    block
    parameters
    ampersandBlock: true
    body
  } as ArrowFunction

  if isStatement body
    braceBlock block
    // Prevent unrolling braced block
    fn.ampersandBlock = false
    delete fn.body

  fn

/**
 * Convert general ExtendedExpression into LeftHandSideExpression.
 * More generally wrap in parentheses if necessary.
 * (Consider renaming and making parentheses depend on context.)
 */
function makeLeftHandSideExpression(expression: ASTNodeObject)
  return expression if expression.parenthesized
  switch (expression.type)
    case "AmpersandRef":
    case "CallExpression":
    case "Identifier":
    case "JSXElement":
    case "JSXFragment":
    case "Literal":
    case "MemberExpression":
    case "NewExpression":
    case "ParenthesizedExpression":
    case "Ref":
    case "Placeholder":
    case "StatementExpression": // wrapIIFE
      return expression

  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: ASTNodeBase)
  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): ASTNode
  let prefix

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

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

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

  signature :=
    modifier:
      async: !!async
    returnType: undefined

  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
  assert
  clone
  convertOptionalType
  deepCopy
  flatJoin
  getTrimmingSpace
  hasAwait
  hasImportDeclaration
  hasYield
  inplaceInsertTrimmingSpace
  inplacePrepend
  insertTrimmingSpace
  isASTNodeObject
  isComma
  isEmptyBareBlock
  isExit
  isFunction
  isStatement
  isWhitespaceOrEmpty
  literalValue
  makeAmpersandFunction
  makeLeftHandSideExpression
  makeNode
  maybeWrap
  maybeUnwrap
  parenthesizeType
  prepend
  removeHoistDecs
  removeParentPointers
  skipIfOnlyWS
  startsWith
  updateParentPointers
  wrapIIFE
  wrapWithReturn
}

DanielXMoore / Civet / 8927536472

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