8091241789

Committed 29 Feb 2024 05:00AM UTC coverage: 91.879% (+0.03%) from 91.848%

Build # 8091241789

Build Type

Pull #1074

github

Committed by

web-flow

Commit Message

Merge 2d526d33d into 2a4e5063d

Pull Request Pull Request #1074: #202 - Don't wrap StatementExpressions in IIFE in declaration

Run Details

1927 of 2095 branches covered (91.98%)

Branch coverage included in aggregate %.

101 of 102 new or added lines in 4 files covered. (99.02%)

3 existing lines in 1 file now uncovered.

13064 of 14221 relevant lines covered (91.86%)

28468.7 hits per line

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

97.3

/source/parser/util.civet

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

import {
  gatherRecursiveWithinFunction
} from ./traversal.civet

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

function hasYield(exp)
  gatherRecursiveWithinFunction(exp, ({ type }) => type is "Yield").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
  }

/**
 * 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 "Ref":
    case "AmpersandRef":
    case "Identifier":
    case "Literal":
    case "IterationExpression": // already a CallExpression
    case "CallExpression":
    case "MemberExpression":
    case "NewExpression":
    case "ParenthesizedExpression":
    case "IfExpression": // already wrapped in parens
    case "DebuggerExpression": // wrapIIFE
    case "SwitchExpression": // wrapIIFE
    case "ThrowExpression": // wrapIIFE
    case "TryExpression": // wrapIIFE
    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?: ASTNodeBase, 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[], async?: string): ASTNode[]
  let prefix

  if async
    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, // TODO: get parent from expression
  }

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

export {
  addParentPointers
  clone
  convertOptionalType
  deepCopy
  getTrimmingSpace
  hasAwait
  hasYield
  insertTrimmingSpace
  isComma
  isEmptyBareBlock
  isExit
  isFunction
  isWhitespaceOrEmpty
  literalValue
  makeAmpersandFunction
  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	TypeSuffix	1✔
8	ReturnTypeAnnotation	1✔
9	StatementTuple	1✔
10	} from ./types.civet	1✔
11		1✔
12	import {	1✔
13	gatherRecursiveWithinFunction	1✔
14	} from ./traversal.civet	1✔
15		1✔
16	/**	1✔
17	* Adds parent pointers to all nodes in the AST. Elements within	1✔
18	* arrays of nodes receive the closest non-array object parent.	1✔
19	*/	1✔
20	function addParentPointers(node: ASTNode, parent?: ASTNodeBase): void	160,008✔
21	if (not node?) return	160,008✔
22	if (typeof node !== "object") return	138,933✔
23		123,048✔
24	// NOTE: Arrays are transparent and skipped when traversing via parent	123,048✔
25	if Array.isArray(node)	123,048✔
26	for child of node	43,459✔
27	addParentPointers(child, parent)	75,105✔
28	return	43,459✔
29		79,589✔
30	node = node as ASTNodeBase	79,589✔
31	node.parent = parent	79,589✔
32	if node.children	79,589✔
33	for child of node.children	160,008✔
34	addParentPointers(child, node)	160,008✔
35		1✔
36	/**	1✔
37	* Clone an AST node including children (removing parent pointes)	1✔
38	* This gives refs new identities which may not be what we want.	1✔
39	*	1✔
40	* TODO: preserve ref identities	1✔
41	*/	1✔
42	function clone(node: ASTNode) {	10✔
43	removeParentPointers(node)	10✔
44	return deepCopy(node)	10✔
45	}	10✔
46		1✔
47	function removeParentPointers(node): void {	63✔
48	if (node == null) return	63!
49	if (typeof node !== "object") return	63✔
50		60✔
51	// NOTE: Arrays are transparent and skipped when traversing via parent	60✔
52	if (Array.isArray(node)) {	63✔
53	for (const child of node) {	5✔
54	removeParentPointers(child)	6✔
55	}	6✔
56	return	5✔
57	}	5✔
58		55✔
59	node.parent = null	55✔
60	if (node.children) {	63✔
61	for (const child of node.children) {	26✔
62	removeParentPointers(child)	47✔
63	}	47✔
64	}	26✔
65	}	63✔
66		1✔
67	function isEmptyBareBlock(node: ASTNode): boolean {	7✔
68	if (node?.type !== "BlockStatement") return false	7!
69	const { bare, expressions } = node	7✔
70	return bare &&	7✔
71	(expressions.length is 0 \|\|	5✔
72	(expressions.length is 1 &&	5✔
73	expressions[0][1]?.type is "EmptyStatement"))	5✔
74	}	7✔
75		1✔
76	function isFunction(node: ASTNode & { type: unknown, async?: boolean }): boolean	67,638✔
77	{ type } := node	67,638✔
78	(or)	67,638✔
79	type is "FunctionExpression"	67,638✔
80	type is "ArrowFunction"	67,638✔
81	type is "MethodDefinition"	67,638✔
82	!!node.async	67,638✔
83	// do blocks can be marked async to prevent automatic await	1✔
84		1✔
85	function isWhitespaceOrEmpty(node): boolean {	401✔
86	if (!node) return true	401✔
87	if (node.type is "Ref") return false	401!
88	if (node.token) return node.token.match(/^\s*$/)	401✔
89	if (node.children) node = node.children	401✔
90	if (!node.length) return true	401✔
91	if (typeof node is "string") return node.match(/^\s*$/)	401✔
92	if (Array.isArray(node)) return node.every(isWhitespaceOrEmpty)	401✔
93	}	401✔
94		1✔
95	/**	1✔
96	* Does this statement force exit from normal flow, implying that the	1✔
97	* line after this one can never execute?	1✔
98	*/	1✔
99	function isExit(node: ASTNode): boolean	45✔
100	node?.type is in [	45✔
101	"ReturnStatement",	45✔
102	"ThrowStatement",	45✔
103	"BreakStatement",	45✔
104	"ContinueStatement"	45✔
105	]	45✔
106		1✔
107	/**	1✔
108	* Detects Comma, CommaDelimiter, and ParameterElementDelimiter	1✔
109	* with an explicit comma, as should be at the top level of	1✔
110	* a "Call" node's `args` array.	1✔
111	* Returns the node whose `token` is ",", or else undefined.	1✔
112	*/	1✔
113	function isComma(node: ASTNode): (ASTLeaf & { token: "," }) \| undefined	55✔
114	if node?.token is ","	55✔
115	node	5✔
116	else if Array.isArray(node) and node.-1?.token is ","	55✔
117	node.-1	55✔
118		1✔
119	/**	1✔
120	* Trims the first single space from the spacing array or node's children if present	1✔
121	* Inserts string `c` in the first position.	1✔
122	* maintains $loc for source maps	1✔
123	*/	1✔
124	function insertTrimmingSpace(target: ASTNode, c: string): ASTNode	4,240✔
125	return target unless target	4,240✔
126		4,097✔
127	if Array.isArray target	4,097✔
128	return c if target.length is 0	1,838✔
129		1,817✔
130	return target.map (e, i) =>	1,817✔
131	return insertTrimmingSpace(e, c) if i is 0	3,350✔
132	return e	1,533✔
133		2,259✔
134	if target.children	2,259✔
135	return {	779✔
136	...target	779✔
137	children: insertTrimmingSpace(target.children, c)	779✔
138	}	779✔
139		1,480✔
140	if target.token	1,480✔
141	return {	1,411✔
142	...target	1,411✔
143	token: target.token.replace(/^ ?/, c)	1,411✔
144	}	1,411✔
145		69✔
146	return target	69✔
147		1✔
148	// Returns leading space as a string, or undefined if none	1✔
149	function getTrimmingSpace(target: ASTNode) {	235✔
150	if (!target) return	235✔
151	if (Array.isArray(target)) return getTrimmingSpace(target[0])	235✔
152	if (target.children) return getTrimmingSpace(target.children[0])	235✔
153	if (target.token) return target.token.match(/^ ?/)[0]	235✔
154	}	235✔
155		1✔
156	// Convert (non-Template) Literal to actual JavaScript value	1✔
157	function literalValue(literal: Literal)	110✔
158	let { raw } = literal	110✔
159	switch (raw) {	110✔
160	case "null": return null	110!
161	case "true": return true	110!
162	case "false": return false	110!
163	}	110✔
164	if (	110✔
165	(raw.startsWith('"') and raw.endsWith('"')) \|\|	110✔
166	(raw.startsWith("'") and raw.endsWith("'"))	100✔
167	) {	110✔
168	return raw.slice(1, -1)	14✔
169	}	14✔
170	const numeric = literal.children.find(	96✔
171	(child) => child.type is "NumericLiteral"	96✔
172	)	96✔
173	if (numeric) {	96✔
174	raw = raw.replace(/_/g, "")	96✔
175	const { token } = numeric	96✔
176	if (token.endsWith("n")) {	96!
177	return BigInt(raw.slice(0, -1))	×
178	} else if (token.match(/[\.eE]/)) {	96✔
179	return parseFloat(raw)	2✔
180	} else if (token.startsWith("0")) {	96✔
181	switch (token.charAt(1).toLowerCase()) {	29✔
182	case "x": return parseInt(raw.replace(/0[xX]/, ""), 16)	29✔
183	case "b": return parseInt(raw.replace(/0[bB]/, ""), 2)	29✔
184	case "o": return parseInt(raw.replace(/0[oO]/, ""), 8)	29✔
185	}	29✔
186	}	29✔
187	return parseInt(raw, 10)	89✔
188	}	89✔
189	throw new Error("Unrecognized literal " + JSON.stringify(literal))	×
190		1✔
191	function startsWith(target: ASTNodeBase, value: RegExp)	1,682✔
192	if (!target) return	1,682!
193	if Array.isArray target	1,682✔
194	let i = 0	955✔
195	let l = target.length	955✔
196	while i < l	955✔
197	const t = target[i]	1,191✔
198	break if t and (t.length or t.token or t.children)	1,191✔
199	i++	252✔
200	if i < l	955✔
201	return startsWith target[i], value	955✔
202	if (target.children) return startsWith target.children, value	1,682✔
203	if (target.token) return value.test target.token	1,682✔
204	if (typeof target is "string") return value.test target	1,682✔
205		1✔
206	/**	1✔
207	* Does this expression have an `await` in it and thus needs to be `async`?	1✔
208	*/	1✔
209	function hasAwait(exp)	714✔
210	gatherRecursiveWithinFunction(exp, ({ type }) => type is "Await").length > 0	714✔
211		1✔
212	function hasYield(exp)	574✔
213	gatherRecursiveWithinFunction(exp, ({ type }) => type is "Yield").length > 0	574✔
214		1✔
215	function deepCopy(node: ASTNode): ASTNode {	879✔
216	if (node == null) return node	879✔
217	if (typeof node !== "object") return node	879✔
218		378✔
219	if (Array.isArray(node)) {	879✔
220	return node.map(deepCopy)	117✔
221	}	117✔
222		261✔
223	// Use from entries to clone objects	261✔
224	// map the values to clone the children	261✔
225	return Object.fromEntries(	261✔
226	Object.entries(node).map(([key, value]) => {	261✔
227	return [key, deepCopy(value)]	653✔
228	})	261✔
229	) as any	261✔
230	}	261✔
231		1✔
232	function makeAmpersandFunction(bodyAfterRef = []): ASTNode	6✔
233	ref := makeRef("$")	6✔
234	body := [ref, ...bodyAfterRef]	6✔
235	parameters :=	6✔
236	type: "Parameters"	6✔
237	children: [ref]	6✔
238	names: []	6✔
239	block :=	6✔
240	expressions: body	6✔
241		6✔
242	return {	6✔
243	type: "ArrowFunction"	6✔
244	signature:	6✔
245	modifier: {}	6✔
246	children: [parameters, " => ", body]	6✔
247	ref	6✔
248	body	6✔
249	ampersandBlock: true	6✔
250	block	6✔
251	parameters	6✔
252	}	6✔
253		1✔
254	/**	1✔
255	* Convert general ExtendedExpression into LeftHandSideExpression.	1✔
256	* More generally wrap in parentheses if necessary.	1✔
257	* (Consider renaming and making parentheses depend on context.)	1✔
258	*/	1✔
259	function makeLeftHandSideExpression(expression)	585✔
260	return expression if expression.parenthesized	585✔
261	switch (expression.type)	585✔
262	case "Ref":	585✔
263	case "AmpersandRef":	585✔
264	case "Identifier":	585✔
265	case "Literal":	585✔
266	case "IterationExpression": // already a CallExpression	585✔
267	case "CallExpression":	585✔
268	case "MemberExpression":	585✔
269	case "NewExpression":	585✔
270	case "ParenthesizedExpression":	585✔
271	case "IfExpression": // already wrapped in parens	585✔
272	case "DebuggerExpression": // wrapIIFE	585✔
273	case "SwitchExpression": // wrapIIFE	585✔
274	case "ThrowExpression": // wrapIIFE	585✔
275	case "TryExpression": // wrapIIFE	585✔
276	case "StatementExpression": // wrapIIFE	585✔
277	return expression	585✔
278		438✔
279	makeNode {	438✔
280	type: "ParenthesizedExpression"	438✔
281	children: ["(", expression, ")"]	438✔
282	expression	438✔
283	implicit: true	438✔
284	}	438✔
285		1✔
286	/**	1✔
287	* Just update parent pointers for the children of a node,	1✔
288	* recursing into arrays but not objects. More efficient version of	1✔
289	* `addParentPointers` when just injecting one new node.	1✔
290	*/	1✔
291	function updateParentPointers(node: ASTNode, parent?: ASTNodeBase, depth = 1): void	13,068✔
292	if (not node?) return	13,068✔
293	if (typeof node !== "object") return	12,355✔
294		9,632✔
295	// NOTE: Arrays are transparent and skipped when traversing via parent	9,632✔
296	if Array.isArray(node)	9,632✔
297	for child of node	2,948✔
298	updateParentPointers(child, parent, depth)	5,713✔
299	return	2,948✔
300		6,684✔
301	node = node as ASTNodeBase	6,684✔
302	if (parent?) node.parent = parent	13,068✔
303	if depth and node.children	13,068✔
304	for child of node.children	13,068✔
305	updateParentPointers(child, node, depth-1)	13,068✔
306		1✔
307	function makeNode<T extends ASTNodeBase>(node: T): T	1,581✔
308	updateParentPointers node	1,581✔
309	node	1,581✔
310		1✔
311	function makeRef(base = "ref", id = base): ASTRef	600✔
312	return {	600✔
313	type: "Ref",	600✔
314	base,	600✔
315	id,	600✔
316	}	600✔
317		1✔
318	/**	1✔
319	* Returns a new ref if the expression needs a ref (not a simple value).	1✔
320	* Otherwise returns undefined.	1✔
321	*/	1✔
322	function needsRef(expression, base = "ref")	181✔
323	switch (expression.type) {	181✔
324	case "Ref":	181✔
325	case "Identifier":	181✔
326	case "Literal":	181✔
327	return	148✔
328	}	181✔
329	return makeRef(base)	33✔
330		1✔
331	// Transform into a ref if needed	1✔
332	function maybeRef(exp: ASTNode, base: string = "ref"): ASTNode	155✔
333	if (!needsRef(exp)) return exp	155✔
334	return makeRef(base)	22✔
335		1✔
336	/**	1✔
337	* Used to ignore the result of __ if it is only whitespace	1✔
338	* Useful to preserve spacing around comments	1✔
339	*/	1✔
340	function skipIfOnlyWS(target)	1,177✔
341	if (!target) return target	1,177✔
342	if (Array.isArray(target)) {	1,177✔
343	if (target.length is 1) {	264✔
344	return skipIfOnlyWS(target[0])	206✔
345	} else if (target.every((e) => (skipIfOnlyWS(e) is undefined))) {	264✔
346	return undefined	43✔
347	}	43✔
348	return target	15✔
349	}	15✔
350	if (target.token != null and target.token.trim() is '') {	1,177✔
351	return undefined	299✔
352	}	299✔
353	return target	142✔
354		1✔
355	/**	1✔
356	* Splice child from children/array, similar to Array.prototype.splice,	1✔
357	* but specifying a child instead of an index. Throw if child not found.	1✔
358	*/	1✔
359	function spliceChild(node: ASTNode, child: ASTNode, del, ...replacements)	11✔
360	children := node?.children ?? node	11!
361	unless Array.isArray children	11✔
UNCOV 362	throw new Error "spliceChild: non-array node has no children field"	×
363	index := children.indexOf child	11✔
364	if index < 0	11✔
UNCOV 365	throw new Error "spliceChild: child not found"	×
366	children.splice index, del, ...replacements	11✔
367		1✔
368	/**	1✔
369	* Convert type suffix of `?: T` to `: undefined \| T`	1✔
370	*/	1✔
371	function convertOptionalType(suffix: TypeSuffix \| ReturnTypeAnnotation): void	6✔
372	if (suffix.t as ASTNodeBase).type is "AssertsType"	6✔
373	spliceChild suffix, suffix.optional, 1, suffix.optional =	1✔
374	type: "Error"	1✔
375	message: "Can't use optional ?: syntax with asserts type"	1✔
376	return	1✔
377	spliceChild suffix, suffix.optional, 1, suffix.optional = undefined	5✔
378	// Return types with \| need to be wrapped in parentheses	5✔
379	wrap := suffix.type is "ReturnTypeAnnotation"	5✔
380	spliceChild suffix, suffix.t, 1, suffix.t = [	5✔
381	getTrimmingSpace suffix.t	5✔
382	wrap and "("	6✔
383	// TODO: avoid parens if unnecessary	6✔
384	"undefined \| "	6✔
385	parenthesizeType insertTrimmingSpace suffix.t, ""	6✔
386	wrap and ")"	6✔
387	]	6✔
388		1✔
389	const typeNeedsNoParens = new Set [	1✔
390	"IdentifierType"	1✔
391	"ImportType"	1✔
392	"LiteralType"	1✔
393	"TupleType"	1✔
394	"ParenthesizedType"	1✔
395	"UnaryType"	1✔
396	]	1✔
397	/**	1✔
398	* Parenthesize type if it might need it in some contexts.	1✔
399	*/	1✔
400	function parenthesizeType(type: ASTNodeBase)	8✔
401	return type if typeNeedsNoParens.has type.type	8✔
UNCOV 402	["(", type, ")"]	×
403		1✔
404	/**	1✔
405	* Wrap an expression in an IIFE, adding async/await if expression	1✔
406	* uses await, or just adding async if specified.	1✔
407	* Returns an Array suitable for `children`.	1✔
408	*/	1✔
409	function wrapIIFE(expressions: StatementTuple[], async?: string): ASTNode[]	46✔
410	let prefix	46✔
411		46✔
412	if async	46✔
413	async = "async "	7✔
414	else if hasAwait expressions	39✔
415	async = "async "	3✔
416	prefix =	3✔
417	type: "Await"	3✔
418	children: ["await "]	3✔
419		46✔
420	block := makeNode {	46✔
421	type: "BlockStatement",	46✔
422	expressions,	46✔
423	children: ["{", expressions, "}"],	46✔
424	bare: false,	46✔
425	root: false,	46✔
426	parent: undefined, // TODO: get parent from expression	46✔
427	}	46✔
428		46✔
429	parameters :=	46✔
430	type: "Parameters"	46✔
431	children: ["()"]	46✔
432	names: []	46✔
433		46✔
434	signature :=	46✔
435	modifier:	46✔
436	async: !!async	46✔
437	returnType: undefined	46✔
438		46✔
439	fn := makeNode {	46✔
440	type: "ArrowFunction",	46✔
441	signature	46✔
442	parameters	46✔
443	returnType: undefined	46✔
444	ts: false	46✔
445	async	46✔
446	block	46✔
447	children: [async, parameters, "=>", block]	46✔
448	}	46✔
449		46✔
450	exp := makeNode	46✔
451	type: "CallExpression"	46✔
452	children: [ makeLeftHandSideExpression(fn), "()" ]	46✔
453		46✔
454	if prefix	46✔
455	return [ makeLeftHandSideExpression [prefix, exp] ]	3✔
456		43✔
457	return [ exp ]	43✔
458		1✔
459	function wrapWithReturn(expression?: ASTNode): ASTNode	388✔
460	const children = expression ? ["return ", expression] : ["return"]	388✔
461		388✔
462	return makeNode {	388✔
463	type: "ReturnStatement",	388✔
464	children,	388✔
465	}	388✔
466		1✔
467	export {	1✔
468	addParentPointers	1✔
469	clone	1✔
470	convertOptionalType	1✔
471	deepCopy	1✔
472	getTrimmingSpace	1✔
473	hasAwait	1✔
474	hasYield	1✔
475	insertTrimmingSpace	1✔
476	isComma	1✔
477	isEmptyBareBlock	1✔
478	isExit	1✔
479	isFunction	1✔
480	isWhitespaceOrEmpty	1✔
481	literalValue	1✔
482	makeAmpersandFunction	1✔
483	makeLeftHandSideExpression	1✔
484	makeNode	1✔
485	makeRef	1✔
486	maybeRef	1✔
487	needsRef	1✔
488	parenthesizeType	1✔
489	skipIfOnlyWS	1✔
490	startsWith	1✔
491	updateParentPointers	1✔
492	wrapIIFE	1✔
493	wrapWithReturn	1✔
494	}	1✔

DanielXMoore / Civet / 8091241789

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