8576869514

Committed 05 Apr 2024 11:30PM UTC coverage: 91.613% (+0.03%) from 91.58%

Build # 8576869514

Build Type

Pull #1151

github

Committed by

web-flow

Commit Message

Merge c0d00c462 into 83f712bf3

Pull Request Pull Request #1151: WIP: Partial placeholders

Run Details

2046 of 2227 branches covered (91.87%)

Branch coverage included in aggregate %.

168 of 171 new or added lines in 3 files covered. (98.25%)

116 existing lines in 2 files now uncovered.

13804 of 15074 relevant lines covered (91.57%)

28494.92 hits per line

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

97.14

/source/parser/util.civet

import type {
  ASTRef
  ASTLeaf
  ASTNode
  ASTNodeBase
  Literal
  Parent
  TypeSuffix
  ReturnTypeAnnotation
  StatementTuple
} from ./types.civet

import {
  gatherRecursiveWithinFunction
} from ./traversal.civet

import {
  processBinaryOpExpression
} from ./op.civet

import {
  processUnaryExpression
} from ./unary.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?: ASTNodeBase): 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 ASTNodeBase
  node.parent = parent
  if node.children
    for 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): void {
  if (node == null) return
  if (typeof node !== "object") return

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

  node.parent = null
  if (node.children) {
    for (const child of node.children) {
      removeParentPointers(child)
    }
  }
}

function isEmptyBareBlock(node: ASTNode): boolean {
  if (node?.type !== "BlockStatement") return false
  const { bare, expressions } = node
  return bare &&
    (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

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

/**
 * Does this statement force exit from normal flow, implying that the
 * line after this one can never execute?
 */
function isExit(node: ASTNode): boolean
  node?.type is in [
    "ReturnStatement",
    "ThrowStatement",
    "BreakStatement",
    "ContinueStatement"
  ]

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

    return target.map (e, i) =>
      return insertTrimmingSpace(e, c) if i is 0
      return e

  if target.children
    return {
      ...target
      children: insertTrimmingSpace(target.children, c)
    }

  if target.token
    return {
      ...target
      token: target.token.replace(/^ ?/, c)
    }

  return target

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

// 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: ASTNodeBase, 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 (target.children) return startsWith target.children, value
  if (target.token) return value.test target.token
  if (typeof target is "string") return value.test target

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

function deepCopy(node: ASTNode): ASTNode {
  if (node == null) return node
  if (typeof node !== "object") return node

  if (Array.isArray(node)) {
    return node.map(deepCopy)
  }

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

function makeAmpersandFunction(bodyAfterRef = []): ASTNode
  ref := makeRef("$")
  body := [ref, ...bodyAfterRef]
  parameters :=
    type: "Parameters"
    children: [ref]
    names: []
  block :=
    expressions: body

  return {
    type: "ArrowFunction"
    signature:
      modifier: {}
    children: [parameters, " => ", body]
    ref
    body
    ampersandBlock: true
    block
    parameters
  }

/**
* A more complete version of makeAmpersandFunction that handles unary prefix
*/
function makeAmpersandFunctionExpression(prefix: UnaryOp[], rhs: AmpersandBlockBody): ASTNode
  let ref, body, typeSuffix

  // Only unary ops
  if (!rhs) {
    body = ref = makeRef("$")
  } else {
    ({ref, typeSuffix} = rhs)
    if (!ref) {
      throw new Error("Could not find ref in ampersand shorthand block")
    }
    body = rhs
  }
  if (prefix.length) {
    body = {
      type: "UnaryExpression",
      children: [ processUnaryExpression(prefix, body, undefined) ]
    }
  }

  parameters := {
    type: "Parameters",
    children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
    names: [],
  }
  expressions := [body]
  block := {
    bare: true,
    expressions,
    children: [expressions],
  }

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

  return {
    type: "ArrowFunction",
    signature: {
      modifier: {
        async,
      },
    },
    children,
    ref,
    body,
    ampersandBlock: true,
    block,
    parameters,
  }

function makeAmpersandBlockRHSBody(typeSuffix, callExpRest?, unaryPostfix?, assign?, binopRHS?): ASTNode
  ref := makeRef("$")

  exp .= {
    type: "AmpersandRef",
    children: [ref],
    names: [],
    ref,
  }

  if (callExpRest) {
    exp.children.push(...callExpRest[1])
  }

  if (unaryPostfix) {
    exp = processUnaryExpression([], exp, unaryPostfix)
  }

  if (assign) {
    // Based on ActualAssignment
    const [op1, more, rhs] = assign
    const lhs = [
      [undefined, exp, ...op1],
      ...more.map((x) => [x[0], x[1], ...x[2]]),
    ]
    exp = {
      type: "AssignmentExpression",
      children: [lhs, rhs],
      names: null,
      lhs,
      assigned: exp,
      exp: rhs,
    }
  }

  if (binopRHS) {
    exp = {
      children: processBinaryOpExpression([exp, binopRHS[1]]),
    }
  }

  // Put at top level for AmpersandFunctionExpression to process
  exp.ref = ref
  exp.typeSuffix = typeSuffix

  return exp

/**
 * Convert general ExtendedExpression into LeftHandSideExpression.
 * More generally wrap in parentheses if necessary.
 * (Consider renaming and making parentheses depend on context.)
 */
function makeLeftHandSideExpression(expression)
  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 "StatementExpression": // wrapIIFE
      return expression

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

/**
 * 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?: Parent, depth = 1): 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
      updateParentPointers(child, parent, depth)
    return

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

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

function makeRef(base = "ref", id = base): ASTRef
  return {
    type: "Ref",
    base,
    id,
  }

/**
 * Returns a new ref if the expression needs a ref (not a simple value).
 * Otherwise returns undefined.
 */
function needsRef(expression, base = "ref")
  switch (expression.type) {
    case "Ref":
    case "Identifier":
    case "Literal":
      return
  }
  return makeRef(base)

// Transform into a ref if needed
function maybeRef(exp: ASTNode, base: string = "ref"): ASTNode
  if (!needsRef(exp)) return exp
  return makeRef(base)

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

export {
  addParentPointers
  assert
  clone
  convertOptionalType
  deepCopy
  getTrimmingSpace
  hasAwait
  hasImportDeclaration
  hasYield
  insertTrimmingSpace
  isComma
  isEmptyBareBlock
  isExit
  isFunction
  isWhitespaceOrEmpty
  literalValue
  makeAmpersandBlockRHSBody
  makeAmpersandFunction
  makeAmpersandFunctionExpression
  makeLeftHandSideExpression
  makeNode
  makeRef
  maybeRef
  needsRef
  parenthesizeType
  skipIfOnlyWS
  startsWith
  updateParentPointers
  wrapIIFE
  wrapWithReturn
}

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

DanielXMoore / Civet / 8576869514

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