9260923959

Committed 27 May 2024 10:40PM UTC coverage: 93.159% (-0.03%) from 93.186%

Build # 9260923959

Build Type

Pull #1272

github

Committed by

web-flow

Commit Message

Merge e37ad9e7f into 8c92741c7

Pull Request Pull Request #1272: Sourcemap fix, show diagnostics with nonfatal parse errors

Run Details

2642 of 2862 branches covered (92.31%)

Branch coverage included in aggregate %.

22 of 23 new or added lines in 1 file covered. (95.65%)

78 existing lines in 3 files now uncovered.

14844 of 15908 relevant lines covered (93.31%)

17864.96 hits per line

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

96.48

/source/parser/util.civet

import type {
  AmpersandBlockBody
  ArrowFunction
  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"}, ...] ]

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?.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
    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 is "Await").length > 0

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

function hasImportDeclaration(exp)
  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"
  "MemberExpression"
  "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

  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

  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
    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
  isToken
  isWhitespaceOrEmpty
  literalValue
  makeLeftHandSideExpression
  makeNode
  maybeWrap
  maybeUnwrap
  parenthesizeType
  prepend
  removeHoistDecs
  removeParentPointers
  skipIfOnlyWS
  startsWith
  updateParentPointers
  wrapIIFE
  wrapWithReturn
}

1	import type {	1✔
2	AmpersandBlockBody	1✔
3	ArrowFunction	1✔
4	ASTLeaf	1✔
5	ASTNode	1✔
6	ASTNodeBase	1✔
7	ASTNodeObject	1✔
8	ASTNodeParent	1✔
9	BlockStatement	1✔
10	IsParent	1✔
11	IsToken	1✔
12	Literal	1✔
13	ParametersNode	1✔
14	StatementNode	1✔
15	TypeSuffix	1✔
16	ReturnTypeAnnotation	1✔
17	StatementTuple	1✔
18	} from ./types.civet	1✔
19		1✔
20	import {	1✔
21	braceBlock	1✔
22	} from ./block.civet	1✔
23		1✔
24	import {	1✔
25	gatherRecursiveWithinFunction	1✔
26	} from ./traversal.civet	1✔
27		1✔
28	import {	1✔
29	makeRef	1✔
30	} from ./ref.civet	1✔
31		1✔
32	assert := {	1✔
33	equal(a: unknown, b: unknown, msg: string): void	1✔
34	/* c8 ignore next */	1✔
35	throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`) if a !== b	1✔
36	}	1✔
37		1✔
38	/**	1✔
39	* Adds parent pointers to all nodes in the AST. Elements within	1✔
40	* arrays of nodes receive the closest non-array object parent.	1✔
41	*/	1✔
42	function addParentPointers(node: ASTNode, parent?: ASTNodeObject): void	182,945✔
43	if (not node?) return	182,945✔
44	if (typeof node !== "object") return	182,945✔
45		139,734✔
46	// NOTE: Arrays are transparent and skipped when traversing via parent	139,734✔
47	if Array.isArray(node)	182,945✔
48	for child of node	50,680✔
49	addParentPointers(child, parent)	79,999✔
50	return	50,680✔
51		89,054✔
52	node = node as ASTNodeObject	89,054✔
53	node.parent = parent if parent?	89,054✔
54	if node.children	182,945✔
55	for each child of node.children	37,602✔
56	addParentPointers(child, node)	100,423✔
57		1✔
58	/**	1✔
59	* Clone an AST node including children (removing parent pointes)	1✔
60	* This gives refs new identities which may not be what we want.	1✔
61	*	1✔
62	* TODO: preserve ref identities	1✔
63	*/	1✔
64	function clone(node: ASTNode)	12✔
65	removeParentPointers(node)	12✔
66	return deepCopy(node)	12✔
67		1✔
68	function removeParentPointers(node: ASTNode): void	100✔
69	return unless node? <? "object"	100✔
70		90✔
71	// NOTE: Arrays are transparent and skipped when traversing via parent	90✔
72	if Array.isArray node	100✔
73	for child of node	6✔
74	removeParentPointers child	8✔
75	return	6✔
76		84✔
77	node.parent = null	84✔
78	if node.children	100✔
79	for child of node.children	44✔
80	removeParentPointers child	80✔
81		1✔
82	// If node is not an ASTNodeObject, wrap it in a special "Wrapper" node	1✔
83	// so that it can have a parent (second argument).	1✔
84	function maybeWrap(node: ASTNode, parent: ASTNodeObject?): ASTNodeObject	165✔
85	unless isASTNodeObject node	165✔
86	updateParentPointers node = {	46✔
87	type: 'Wrapper'	46✔
88	children: [ node ]	46✔
89	parent	46✔
90	}	46✔
91	node	165✔
92		1✔
93	// Unwrap "Wrapper" node if there is one.	1✔
94	// You should call `updateParentPointers` after this gets assigned somewhere.	1✔
95	function maybeUnwrap(node: ASTNode): ASTNode	171✔
96	if node?.type is "Wrapper"	171✔
97	node.children[0]	46✔
98	else	125✔
99	node	125✔
100		1✔
101	function isASTNodeObject(node: ASTNode): node is ASTNodeObject	1,520✔
102	(and)	1,520✔
103	node <? "object"	1,520✔
104	node?	1,520✔
105	not Array.isArray node	1,520✔
106		1✔
107	function isParent(node: ASTNode): node is IsParent	12,069✔
108	node? and node.children?	12,069✔
109		1✔
110	function isToken(node: ASTNode): node is IsToken	6,543✔
111	node? and node.token?	6,543✔
112		1✔
113	function isEmptyBareBlock(node: ASTNode): boolean	8✔
114	if (node?.type !== "BlockStatement") return false	8!
115	{ bare, expressions } := node	8✔
116	return bare and	8✔
117	expressions is like [], [ [, {type: "EmptyStatement"}, ...] ]	8✔
118		1✔
119	function isFunction(node: ASTNode & { type: unknown, async?: boolean }): boolean	66,276✔
120	{ type } := node	66,276✔
121	(or)	66,276✔
122	type is "FunctionExpression"	66,276✔
123	type is "ArrowFunction"	66,276✔
124	type is "MethodDefinition"	66,276✔
125	!!node.async	66,276✔
126	// do blocks can be marked async to prevent automatic await	1✔
127		1✔
128	// Keep this in sync with StatementNode in types.civet	1✔
129	statementTypes := new Set [	1✔
130	"BlockStatement"	1✔
131	"BreakStatement"	1✔
132	"ComptimeStatement"	1✔
133	"ContinueStatement"	1✔
134	"DebuggerStatement"	1✔
135	"Declaration"	1✔
136	"DoStatement"	1✔
137	"ForStatement"	1✔
138	"IfStatement"	1✔
139	"IterationStatement"	1✔
140	"LabeledStatement"	1✔
141	"ReturnStatement"	1✔
142	"SwitchStatement"	1✔
143	"ThrowStatement"	1✔
144	"TryStatement"	1✔
145	]	1✔
146	function isStatement(node: ASTNode): node is StatementNode	186✔
147	(and)	186✔
148	isASTNodeObject node	186✔
149	node.type? // forbid leaf	127✔
150	statementTypes.has node.type	186✔
151		1✔
152	function isWhitespaceOrEmpty(node): boolean {	962✔
153	if (!node) return true	962✔
154	if (node.type is "Ref") return false	962✔
155	if (node.token) return /^\s*$/.test(node.token)	962✔
156	if (node.children) node = node.children	962✔
157	if (!node.length) return true	962✔
158	if (typeof node is "string") return /^\s*$/.test(node)	962✔
159	if (Array.isArray(node)) return node.every(isWhitespaceOrEmpty)	962!
160	return false	×
161	}	×
162		1✔
163	/**	1✔
164	* Does this statement force exit from normal flow, or loop forever,	1✔
165	* implying that the line after this one can never execute?	1✔
166	*/	1✔
167	function isExit(node: ASTNode): boolean	2,092✔
168	return false unless node?	2,092✔
169	switch node.type	2,068✔
170	// Exit from normal flow	2,068✔
171	when "ReturnStatement", "ThrowStatement", "BreakStatement", "ContinueStatement"	2,092✔
172	true	172✔
173	// if checks then and else clause	2,092✔
174	when "IfStatement"	2,092✔
175	(and)	175✔
176	isExit node.then	175✔
177	isExit node.else?.block	175✔
178	when "BlockStatement"	2,092✔
179	// [1] extracts statement from [indent, statement, delim]	256✔
180	node.expressions.some (s) => isExit s[1]	256✔
181	// Infinite loops	2,092✔
182	when "IterationStatement"	2,092✔
183	(and)	28✔
184	node.condition?.type is "ParenthesizedExpression"	28✔
185	node.condition.expression?.type is "Literal"	28✔
186	node.condition.expression?.raw is "true"	18✔
187	gatherRecursiveWithinFunction(node.block,	18✔
188	.type is "BreakStatement").length is 0	28✔
189	// TODO: Distinguish between break of this loop vs. break of inner loops	2,092✔
190	else	2,092✔
191	false	1,437✔
192		1✔
193	/**	1✔
194	* Detects Comma, CommaDelimiter, and ParameterElementDelimiter	1✔
195	* with an explicit comma, as should be at the top level of	1✔
196	* a "Call" node's `args` array.	1✔
197	* Returns the node whose `token` is ",", or else undefined.	1✔
198	*/	1✔
199	function isComma(node: ASTNode): (ASTLeaf & { token: "," }) \| undefined	79✔
200	if node?.token is ","	79✔
201	node	14✔
202	else if Array.isArray(node) and node.-1?.token is ","	65✔
203	node.-1	24✔
204		1✔
205	/**	1✔
206	* Trims the first single space from the spacing array or node's children if present	1✔
207	* Inserts string `c` in the first position.	1✔
208	* maintains $loc for source maps	1✔
209	*/	1✔
210	function insertTrimmingSpace(target: ASTNode, c: string): ASTNode	8,466✔
211	return target unless target?	8,466✔
212		8,444✔
213	if Array.isArray target	8,466✔
214	return c if target.length is 0	4,029✔
215		4,008✔
216	target.map (e, i) =>	4,008✔
217	if i is 0	5,658✔
218	insertTrimmingSpace(e, c)	4,008✔
219	else	1,650✔
220	e	1,650✔
221	else if isParent target	4,415✔
222	{	1,034✔
223	...target	1,034✔
224	children: insertTrimmingSpace(target.children, c)	1,034✔
225	}	1,034✔
226	else if isToken target	3,381✔
227	{	3,351✔
228	...target	3,351✔
229	token: target.token.replace(/^ ?/, c)	3,351✔
230	}	3,351✔
231	else	30✔
232	target	30✔
233		1✔
234	function inplaceInsertTrimmingSpace(target: ASTNode, c: string): void	45✔
235	return target unless target?	45!
236	if Array.isArray target	45✔
237	inplaceInsertTrimmingSpace target[0], c	24✔
238	else if isParent target	21✔
239	inplaceInsertTrimmingSpace target.children, c	9✔
240	else if isToken target	12✔
241	target.token = target.token.replace(/^ ?/, c)	12✔
242		1✔
243	// Returns leading space as a string, or undefined if none	1✔
244	function getTrimmingSpace(target: ASTNode)	1,007✔
245	return unless target?	1,007✔
246	if Array.isArray target	1,007✔
247	getTrimmingSpace target[0]	110✔
248	else if isParent target	882✔
249	getTrimmingSpace target.children[0]	516✔
250	else if isToken target	366✔
251	target.token.match(/^ ?/)![0]	260✔
252		1✔
253	// Glom content e.g. whitespace into AST nodes	1✔
254	// NOTE: This can get weird if we depend on the specific location of children	1✔
255	function prepend(prefix: ASTNode, node: ASTNode): ASTNode	23,468✔
256	return node unless prefix and prefix.length	23,468✔
257	if Array.isArray node	23,468✔
258	[prefix, ...node]	97✔
259	else if isParent node	2,759✔
260	{	2,756✔
261	...node	2,756✔
262	children: [prefix, ...node.children]	2,756✔
263	} as typeof node	2,756✔
264	// NOTE: Not glomming into an AST leaf; would need to flatten prefix	3✔
265	else	3✔
266	[prefix, node]	3✔
267		1✔
268	function inplacePrepend(prefix: ASTNode, node: ASTNode): void	15✔
269	return unless prefix	15!
270	return if Array.isArray(prefix) and not prefix.length	15!
271	if Array.isArray node	15✔
272	node.unshift prefix	3✔
273	else if isParent node	12✔
274	node.children.unshift prefix	12✔
275	else	×
276	throw new Error "Can't prepend to a leaf node"	×
277		1✔
278	// Convert (non-Template) Literal to actual JavaScript value	1✔
279	function literalValue(literal: Literal)	126✔
280	let { raw } = literal	126✔
281	switch (raw) {	126✔
282	case "null": return null	126!
283	case "true": return true	126!
284	case "false": return false	126!
285	}	126✔
286	if (	126✔
287	(raw.startsWith('"') and raw.endsWith('"')) \|\|	126✔
288	(raw.startsWith("'") and raw.endsWith("'"))	126✔
289	) {	126✔
290	return raw.slice(1, -1)	26✔
291	}	26✔
292	const numeric = literal.children.find(	100✔
293	(child) => child.type is "NumericLiteral"	100✔
294	)	100✔
295	if (numeric) {	100✔
296	raw = raw.replace(/_/g, "")	100✔
297	const { token } = numeric	100✔
298	if (token.endsWith("n")) {	100!
299	return BigInt(raw.slice(0, -1))	×
300	} else if (token.match(/[\.eE]/)) {	100✔
301	return parseFloat(raw)	2✔
302	} else if (token.startsWith("0")) {	100✔
303	switch (token.charAt(1).toLowerCase()) {	29✔
304	case "x": return parseInt(raw.replace(/0[xX]/, ""), 16)	29✔
305	case "b": return parseInt(raw.replace(/0[bB]/, ""), 2)	29✔
306	case "o": return parseInt(raw.replace(/0[oO]/, ""), 8)	29✔
307	}	29✔
308	}	29✔
309	return parseInt(raw, 10)	93✔
310	}	93!
311	throw new Error("Unrecognized literal " + JSON.stringify(literal))	×
312		1✔
313	function startsWith(target: ASTNode, value: RegExp)	1,908✔
314	if (!target) return	1,908!
315	if Array.isArray target	1,908✔
316	let i = 0	1,080✔
317	let l = target.length	1,080✔
318	while i < l	1,080✔
319	const t = target[i]	1,348✔
320	break if t and (t.length or t.token or t.children)	1,348✔
321	i++	285✔
322	if i < l	1,080✔
323	return startsWith target[i], value	1,063✔
324	if (typeof target is "string") return value.test target	1,908✔
325	if (target.children) return startsWith target.children, value	1,908✔
326	if (target.token) return value.test target.token	1,908✔
327		1✔
328	/**	1✔
329	* Does this expression have an `await` in it and thus needs to be `async`?	1✔
330	* Skips over nested functions, which have their own async behavior.	1✔
331	*/	1✔
332	function hasAwait(exp)	869✔
333	gatherRecursiveWithinFunction(exp, .type is "Await").length > 0	869✔
334		1✔
335	function hasYield(exp)	810✔
336	gatherRecursiveWithinFunction(exp, .type is "Yield").length > 0	810✔
337		1✔
338	function hasImportDeclaration(exp)	×
339	gatherRecursiveWithinFunction(exp, .type is "ImportDeclaration").length > 0	×
340		1✔
341	/**	1✔
342	* Copy an AST node deeply, including children.	1✔
343	* Ref nodes maintain identity	1✔
344	*/	1✔
345	function deepCopy(node: ASTNode): ASTNode	1,482✔
346	if (node == null) return node	1,482✔
347	if (typeof node !== "object") return node	1,482✔
348		644✔
349	if Array.isArray node	1,482✔
350	return node.map deepCopy	208✔
351		436✔
352	if node?.type is "Ref" return node	1,482✔
353		428✔
354	// Use from entries to clone objects	428✔
355	// map the values to clone the children	428✔
356	return Object.fromEntries(	428✔
357	Object.entries(node).map [key, value] =>	428✔
358	return [key, deepCopy(value)]	1,106✔
359		428✔
360	) as any	428✔
361		1✔
362	/**	1✔
363	* When cloning subtrees sometimes we need to remove hoistDecs	1✔
364	*/	1✔
365	function removeHoistDecs(node: ASTNode): void	100✔
366	if (not node?) return	100!
367	if (typeof node !== "object") return	100✔
368		90✔
369	if "hoistDec" in node	100✔
370	node.hoistDec = undefined	1✔
371		90✔
372	// NOTE: Arrays are transparent and skipped when traversing via parent	90✔
373	if Array.isArray(node)	100✔
374	for child of node	6✔
375	removeHoistDecs(child)	8✔
376	return	6✔
377		84✔
378	if node.children	100✔
379	for child of node.children	44✔
380	removeHoistDecs(child)	80✔
381		1✔
382	skipParens := new Set [	1✔
383	"AmpersandRef"	1✔
384	"CallExpression"	1✔
385	"Identifier"	1✔
386	"JSXElement"	1✔
387	"JSXFragment"	1✔
388	"Literal"	1✔
389	"MemberExpression"	1✔
390	"NewExpression"	1✔
391	"ParenthesizedExpression"	1✔
392	"Ref"	1✔
393	"Placeholder"	1✔
394	"StatementExpression" // wrapIIFE	1✔
395	]	1✔
396		1✔
397	/**	1✔
398	* Convert general ExtendedExpression into LeftHandSideExpression.	1✔
399	* More generally wrap in parentheses if necessary.	1✔
400	* (Consider renaming and making parentheses depend on context.)	1✔
401	*/	1✔
402	function makeLeftHandSideExpression(expression: ASTNode)	720✔
403	if isASTNodeObject expression	720✔
404	return expression if expression.parenthesized	699!
405	return expression if skipParens.has expression.type	699✔
406		523✔
407	makeNode {	523✔
408	type: "ParenthesizedExpression"	523✔
409	children: ["(", expression, ")"]	523✔
410	expression	523✔
411	implicit: true	523✔
412	}	523✔
413		1✔
414	/**	1✔
415	* Just update parent pointers for the children of a node,	1✔
416	* recursing into arrays but not objects. More efficient version of	1✔
417	* `addParentPointers` when just injecting one new node.	1✔
418	*/	1✔
419	function updateParentPointers(node: ASTNode, parent?: ASTNodeParent, depth = 1): void	23,574✔
420	return unless node?	23,574✔
421	return unless node <? "object"	23,574✔
422		16,993✔
423	// NOTE: Arrays are transparent and skipped when traversing via parent	16,993✔
424	if Array.isArray(node)	23,574✔
425	for each child of node	8,171✔
426	updateParentPointers(child, parent, depth)	8,171✔
427	return	4,093✔
428		12,900✔
429	node = node as ASTNodeObject	12,900✔
430	node.parent = parent if parent?	12,900✔
431	if depth and isParent node	23,574✔
432	for each child of node.children	3,949✔
433	updateParentPointers(child, node, depth-1)	11,487✔
434		1✔
435	function makeNode<T extends ASTNodeObject>(node: T): T	3,034✔
436	updateParentPointers node	3,034✔
437	node	3,034✔
438		1✔
439	/**	1✔
440	* Used to ignore the result of __ if it is only whitespace	1✔
441	* Useful to preserve spacing around comments	1✔
442	*/	1✔
443	function skipIfOnlyWS(target)	1,278✔
444	if (!target) return target	1,278✔
445	if (Array.isArray(target)) {	1,278✔
446	if (target.length is 1) {	286✔
447	return skipIfOnlyWS(target[0])	226✔
448	} else if (target.every((e) => (skipIfOnlyWS(e) is undefined))) {	286✔
449	return undefined	45✔
450	}	45✔
451	return target	15✔
452	}	15✔
453	if (target.token != null and target.token.trim() is '') {	1,278✔
454	return undefined	323✔
455	}	323✔
456	return target	153✔
457		1✔
458	/**	1✔
459	* Splice child from children/array, similar to Array.prototype.splice,	1✔
460	* but specifying a child instead of an index. Throw if child not found.	1✔
461	*/	1✔
462	function spliceChild(node: ASTNode, child: ASTNode, del, ...replacements)	11✔
463	children := node?.children ?? node	11!
464	unless Array.isArray children	11!
UNCOV 465	throw new Error "spliceChild: non-array node has no children field"	×
466	index := children.indexOf child	11✔
467	if index < 0	11!
UNCOV 468	throw new Error "spliceChild: child not found"	×
469	children.splice index, del, ...replacements	11✔
470		1✔
471	/**	1✔
472	* Convert type suffix of `?: T` to `: undefined \| T`	1✔
473	*/	1✔
474	function convertOptionalType(suffix: TypeSuffix \| ReturnTypeAnnotation): void	6✔
475	if (suffix.t as ASTNodeBase).type is "AssertsType"	6✔
476	spliceChild suffix, suffix.optional, 1, suffix.optional =	1✔
477	type: "Error"	1✔
478	message: "Can't use optional ?: syntax with asserts type"	1✔
479	return	1✔
480	spliceChild suffix, suffix.optional, 1, suffix.optional = undefined	5✔
481	// Return types with \| need to be wrapped in parentheses	5✔
482	wrap := suffix.type is "ReturnTypeAnnotation"	5✔
483	spliceChild suffix, suffix.t, 1, suffix.t = [	5✔
484	getTrimmingSpace suffix.t	5✔
485	wrap and "("	6✔
486	// TODO: avoid parens if unnecessary	6✔
487	"undefined \| "	6✔
488	parenthesizeType insertTrimmingSpace suffix.t, ""	6✔
489	wrap and ")"	6✔
490	]	6✔
491		1✔
492	const typeNeedsNoParens = new Set [	1✔
493	"IdentifierType"	1✔
494	"ImportType"	1✔
495	"LiteralType"	1✔
496	"TupleType"	1✔
497	"ParenthesizedType"	1✔
498	"UnaryType"	1✔
499	]	1✔
500	/**	1✔
501	* Parenthesize type if it might need it in some contexts.	1✔
502	*/	1✔
503	function parenthesizeType(type: ASTNodeBase)	8✔
504	return type if typeNeedsNoParens.has type.type	8!
UNCOV 505	["(", type, ")"]	×
506		1✔
507	/**	1✔
508	* Wrap an expression in an IIFE, adding async/await if expression	1✔
509	* uses await, or just adding async if specified.	1✔
510	* Returns an Array suitable for `children`.	1✔
511	*/	1✔
512	function wrapIIFE(expressions: StatementTuple[], asyncFlag?: boolean): ASTNode	50✔
513	let prefix	50✔
514		50✔
515	async := []	50✔
516	if asyncFlag	50✔
517	async.push "async "	10✔
518	else if hasAwait expressions	40✔
519	async.push "async "	2✔
520	prefix =	2✔
521	type: "Await"	2✔
522	children: ["await "]	2✔
523		50✔
524	block := makeNode {	50✔
525	type: "BlockStatement"	50✔
526	expressions	50✔
527	children: ["{", expressions, "}"]	50✔
528	bare: false	50✔
529	root: false	50✔
530	}	50✔
531		50✔
532	parameters :=	50✔
533	type: "Parameters"	50✔
534	children: ["()"]	50✔
535	names: []	50✔
536		50✔
537	signature :=	50✔
538	modifier:	50✔
539	async: !!async.length	50✔
540	returnType: undefined	50✔
541		50✔
542	fn := makeNode {	50✔
543	type: "ArrowFunction"	50✔
544	signature	50✔
545	parameters	50✔
546	returnType: undefined	50✔
547	ts: false	50✔
548	async	50✔
549	block	50✔
550	children: [async, parameters, "=>", block]	50✔
551	}	50✔
552		50✔
553	exp := makeNode	50✔
554	type: "CallExpression"	50✔
555	children: [ makeLeftHandSideExpression(fn), "()" ]	50✔
556		50✔
557	if prefix	50✔
558	return makeLeftHandSideExpression [prefix, exp]	2✔
559		48✔
560	return exp	48✔
561		1✔
562	function wrapWithReturn(expression?: ASTNode): ASTNode	409✔
563	const children = expression ? ["return ", expression] : ["return"]	409✔
564		409✔
565	return makeNode {	409✔
566	type: "ReturnStatement",	409✔
567	children,	409✔
568	expression,	409✔
569	parent: expression?.parent,	409✔
570	}	409✔
571		1✔
572	function flatJoin<T, S>(array: T[][], separator: S): (T \| S)[]	224✔
573	result := []	224✔
574	for each items, i of array	412✔
575	result.push separator if i	412✔
576	result.push ...items	412✔
577	result	224✔
578		1✔
579	export {	1✔
580	addParentPointers	1✔
581	assert	1✔
582	clone	1✔
583	convertOptionalType	1✔
584	deepCopy	1✔
585	flatJoin	1✔
586	getTrimmingSpace	1✔
587	hasAwait	1✔
588	hasImportDeclaration	1✔
589	hasYield	1✔
590	inplaceInsertTrimmingSpace	1✔
591	inplacePrepend	1✔
592	insertTrimmingSpace	1✔
593	isASTNodeObject	1✔
594	isComma	1✔
595	isEmptyBareBlock	1✔
596	isExit	1✔
597	isFunction	1✔
598	isStatement	1✔
599	isToken	1✔
600	isWhitespaceOrEmpty	1✔
601	literalValue	1✔
602	makeLeftHandSideExpression	1✔
603	makeNode	1✔
604	maybeWrap	1✔
605	maybeUnwrap	1✔
606	parenthesizeType	1✔
607	prepend	1✔
608	removeHoistDecs	1✔
609	removeParentPointers	1✔
610	skipIfOnlyWS	1✔
611	startsWith	1✔
612	updateParentPointers	1✔
613	wrapIIFE	1✔
614	wrapWithReturn	1✔
615	}	1✔

DanielXMoore / Civet / 9260923959

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