8871239985

Committed 28 Apr 2024 11:45PM UTC coverage: 92.933% (+0.02%) from 92.916%

Build # 8871239985

Build Type

Pull #1199

github

Committed by

web-flow

Commit Message

Merge 2c1a161e1 into 77d34733c

Pull Request Pull Request #1199: "is like" pattern matching operator

Run Details

2461 of 2686 branches covered (91.62%)

Branch coverage included in aggregate %.

195 of 196 new or added lines in 11 files covered. (99.49%)

97 existing lines in 4 files now uncovered.

14412 of 15470 relevant lines covered (93.16%)

17594.17 hits per line

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

95.9

/source/parser/block.civet

import type {
  ASTNode
  ASTNodeBase
  BlockStatement
  FunctionNode
  StatementTuple
} from ./types.civet

import {
  addParentPointers
  updateParentPointers
  startsWith
} from ./util.civet

import {
  findAncestor
  gatherRecursiveAll
  gatherRecursive
} from ./traversal.civet

import {
  processReturn
} from ./function.civet

/**
 * Duplicate a block and attach statements prefixing the block.
 * Adds braces if the block is bare.
 *
 * @returns the duplicated block with prefix statements attached or the unchanged block.
 */
function blockWithPrefix(prefixStatements: StatementTuple[] | undefined, block: BlockStatement)
  if prefixStatements and prefixStatements.length
    const indent = getIndent(block.expressions[0])
    // Match prefix statements to block indent level
    if indent
      //@ts-ignore
      prefixStatements = prefixStatements.map (statement) =>
        [indent, ...statement.slice(1)]

    const expressions = [...prefixStatements, ...block.expressions]
    // blockPrefix wasn't previously a child, so now needs parent pointers
    addParentPointers prefixStatements, block

    block = {
      ...block,
      expressions,
      children: block.children is block.expressions ? expressions :
        block.children.map((c) => c is block.expressions ? expressions : c),
    }
    braceBlock block

    updateParentPointers block

  return block

// Add braces if block lacks them
function braceBlock(block: BlockStatement)
  if block.bare
    if block.children is block.expressions
      block.children = [block.expressions]
    block.children.unshift(" {")
    block.children.push "}"
    { implicitlyReturned } := block
    block.bare = block.implicitlyReturned = false
    if implicitlyReturned
      processReturn block.parent as FunctionNode, true

function duplicateBlock(block: BlockStatement): BlockStatement
  expressions := [...block.expressions]
  let children
  if block.children is block.expressions
    children = expressions
  else
    children = [...block.children]
    children.splice(children.indexOf(block.expressions), 1, expressions)
  return {
    ...block,
    expressions,
    children,
  }

function makeEmptyBlock(): BlockStatement
  const expressions = []
  return {
    type: "BlockStatement",
    expressions,
    children: ["{", expressions, "}"],
    bare: false,
    empty: true,
  }

/**
Like an empty block but can only be used inside another
real block and won't be wrapped with braces.
*/
function makeBlockFragment(): BlockStatement
  expressions: StatementTuple[] := []
  return {
    type: "BlockStatement",
    children: expressions,
    parent: undefined,
    expressions,
    bare: false,
    root: false
  }

/**
 * Replace `child` with `replacement` inside the `block`.
 * Assumes a `StatementTuple[]` for `block.expressions`
 */
function replaceBlockExpression(node: BlockStatement, child: ASTNodeBase, replacement: ASTNodeBase): void
  found .= false

  { expressions } := node

  for (let i = 0, l = expressions.length; i < l; i++)
    statement := expressions[i]
    [, s,] := statement

    if s is child
      statement[1] = replacement
      replacement.parent = node
      found = true
      break

  throw new Error("Could not find child to replace") unless found

/**
 * Gets the indentation node from a statement. Includes newline,
 * excludes comments, strips location info.
 */
function getIndent(statement: StatementTuple) {
  let indent = statement?.[0]
  if (Array.isArray(indent)) {
    indent = indent.flat(Infinity)

    return indent.filter((n) => n and !(n.type is "Comment")).map((n) => {
      if (typeof n is "string") return n
      if (n.token != null) return n.token
      return ""
    })
  }
  return indent
}

function hoistRefDecs(statements: StatementTuple[]): void
  gatherRecursiveAll(statements, (s) => s.hoistDec)
    .forEach (node) =>
      let { hoistDec } = node
      node.hoistDec = null

      const { ancestor, child } = findAncestor node, (ancestor) =>
        ancestor.type is "BlockStatement" and (!ancestor.bare or ancestor.root)

      if ancestor
        insertHoistDec(ancestor, child, hoistDec)
      else
        throw new Error("Couldn't find block to hoist declaration into.")

      return

function insertHoistDec(block: BlockStatement, node: ASTNode | StatementTuple, dec: ASTNode): void
  // NOTE: This is more accurately 'statements'
  { expressions } := block
  index := expressions.findIndex (exp) =>
    exp is node or (Array.isArray(exp) and exp[1] is node)

  if index < 0
    throw new Error("Couldn't find expression in block for hoistable declaration.")

  statement := [ expressions[index][0], dec, ";" ] as StatementTuple
  expressions[index][0] = ""
  expressions.splice index, 0, statement

  // hoistDec wasn't previously a child, so now needs parent pointers
  addParentPointers dec, block

function processBlocks(statements: StatementTuple[]): void
  insertSemicolon(statements)
  gatherRecursive statements, .type is "BlockStatement"
  .forEach ({ expressions }) =>
    processBlocks expressions

/**
* Automatic Semicolon Insertion (ASI):
* Avoid automatic continuation onto lines that start with
* certain characters by adding an explicit semicolon. See
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#automatic_semicolon_insertion
*/
function insertSemicolon(statements: StatementTuple[]): void
  l := statements.length
  for each s, i of statements
    if i < l - 1
      if needsPrecedingSemicolon(statements[i + 1][1])
        delim := s[2]
        if !delim
          s[2] = ";"
        // If delim is an object assume it already has a semicolon
        // TODO: trailing comments might violate this assumption
        else if typeof delim is "string" and !delim.match(/;/)
          s[2] = `;${delim}`

function needsPrecedingSemicolon(exp: ASTNode)
  return false unless exp

  if Array.isArray exp // for chained conditionals
    // Recurse into first non-null element of array
    for each child of exp
      continue unless child?
      return needsPrecedingSemicolon child
    return false
  
  if exp <? "string"
    return /^\s*[\(\[\`\+\-\/]/.test exp

  switch exp.type
    when "ParenthesizedExpression", "ArrayExpression", "ArrowFunction", "TemplateLiteral", "RegularExpressionLiteral", "RangeExpression", "ComputedPropertyName"
      true
    when "AssignmentExpression"
      startsWith(exp, /^(\[|\()/)
    when "Literal"
      exp.raw?.startsWith('-') or exp.raw?.startsWith('+')
    when "PipelineExpression", "UnwrappedExpression"
      // skip first child which is whitespace
      needsPrecedingSemicolon exp.children[1]
    else
      // descend into children for things like:
      // IterationExpression
      //   CallExpression
      //     ParenthesizedExpression
      if exp.children
        needsPrecedingSemicolon exp.children

export {
  blockWithPrefix
  braceBlock
  duplicateBlock
  getIndent
  hoistRefDecs
  makeBlockFragment
  makeEmptyBlock
  processBlocks
  replaceBlockExpression
}

1	import type {	1✔
2	ASTNode	1✔
3	ASTNodeBase	1✔
4	BlockStatement	1✔
5	FunctionNode	1✔
6	StatementTuple	1✔
7	} from ./types.civet	1✔
8		1✔
9	import {	1✔
10	addParentPointers	1✔
11	updateParentPointers	1✔
12	startsWith	1✔
13	} from ./util.civet	1✔
14		1✔
15	import {	1✔
16	findAncestor	1✔
17	gatherRecursiveAll	1✔
18	gatherRecursive	1✔
19	} from ./traversal.civet	1✔
20		1✔
21	import {	1✔
22	processReturn	1✔
23	} from ./function.civet	1✔
24		1✔
25	/**	1✔
26	* Duplicate a block and attach statements prefixing the block.	1✔
27	* Adds braces if the block is bare.	1✔
28	*	1✔
29	* @returns the duplicated block with prefix statements attached or the unchanged block.	1✔
30	*/	1✔
31	function blockWithPrefix(prefixStatements: StatementTuple[] \| undefined, block: BlockStatement)	408✔
32	if prefixStatements and prefixStatements.length	408✔
33	const indent = getIndent(block.expressions[0])	79✔
34	// Match prefix statements to block indent level	79✔
35	if indent	79✔
36	//@ts-ignore	73✔
37	prefixStatements = prefixStatements.map (statement) =>	73✔
38	[indent, ...statement.slice(1)]	86✔
39		79✔
40	const expressions = [...prefixStatements, ...block.expressions]	79✔
41	// blockPrefix wasn't previously a child, so now needs parent pointers	79✔
42	addParentPointers prefixStatements, block	79✔
43		79✔
44	block = {	79✔
45	...block,	79✔
46	expressions,	79✔
47	children: block.children is block.expressions ? expressions :	79!
48	block.children.map((c) => c is block.expressions ? expressions : c),	79✔
49	}	79✔
50	braceBlock block	79✔
51		79✔
52	updateParentPointers block	79✔
53		408✔
54	return block	408✔
55		1✔
56	// Add braces if block lacks them	1✔
57	function braceBlock(block: BlockStatement)	268✔
58	if block.bare	268✔
59	if block.children is block.expressions	163✔
UNCOV 60	block.children = [block.expressions]	×
61	block.children.unshift(" {")	163✔
62	block.children.push "}"	163✔
63	{ implicitlyReturned } := block	163✔
64	block.bare = block.implicitlyReturned = false	163✔
65	if implicitlyReturned	163✔
66	processReturn block.parent as FunctionNode, true	5✔
67		1✔
68	function duplicateBlock(block: BlockStatement): BlockStatement	5✔
69	expressions := [...block.expressions]	5✔
70	let children	5✔
71	if block.children is block.expressions	5✔
UNCOV 72	children = expressions	×
73	else	5✔
74	children = [...block.children]	5✔
75	children.splice(children.indexOf(block.expressions), 1, expressions)	5✔
76	return {	5✔
77	...block,	5✔
78	expressions,	5✔
79	children,	5✔
80	}	5✔
81		1✔
82	function makeEmptyBlock(): BlockStatement	30✔
83	const expressions = []	30✔
84	return {	30✔
85	type: "BlockStatement",	30✔
86	expressions,	30✔
87	children: ["{", expressions, "}"],	30✔
88	bare: false,	30✔
89	empty: true,	30✔
90	}	30✔
91		1✔
92	/**	1✔
93	Like an empty block but can only be used inside another	1✔
94	real block and won't be wrapped with braces.	1✔
95	*/	1✔
96	function makeBlockFragment(): BlockStatement	575✔
97	expressions: StatementTuple[] := []	575✔
98	return {	575✔
99	type: "BlockStatement",	575✔
100	children: expressions,	575✔
101	parent: undefined,	575✔
102	expressions,	575✔
103	bare: false,	575✔
104	root: false	575✔
105	}	575✔
106		1✔
107	/**	1✔
108	* Replace `child` with `replacement` inside the `block`.	1✔
109	* Assumes a `StatementTuple[]` for `block.expressions`	1✔
110	*/	1✔
111	function replaceBlockExpression(node: BlockStatement, child: ASTNodeBase, replacement: ASTNodeBase): void	5✔
112	found .= false	5✔
113		5✔
114	{ expressions } := node	5✔
115		5✔
116	for (let i = 0, l = expressions.length; i < l; i++)	5✔
117	statement := expressions[i]	5✔
118	[, s,] := statement	5✔
119		5✔
120	if s is child	5✔
121	statement[1] = replacement	5✔
122	replacement.parent = node	5✔
123	found = true	5✔
124	break	5✔
125		5✔
126	throw new Error("Could not find child to replace") unless found	5✔
127		1✔
128	/**	1✔
129	* Gets the indentation node from a statement. Includes newline,	1✔
130	* excludes comments, strips location info.	1✔
131	*/	1✔
132	function getIndent(statement: StatementTuple) {	197✔
133	let indent = statement?.[0]	197✔
134	if (Array.isArray(indent)) {	197✔
135	indent = indent.flat(Infinity)	121✔
136		121✔
137	return indent.filter((n) => n and !(n.type is "Comment")).map((n) => {	121✔
138	if (typeof n is "string") return n	240!
139	if (n.token != null) return n.token	240✔
UNCOV 140	return ""	×
141	})	121✔
142	}	121✔
143	return indent	76✔
144	}	76✔
145		1✔
146	function hoistRefDecs(statements: StatementTuple[]): void	2,358✔
147	gatherRecursiveAll(statements, (s) => s.hoistDec)	2,358✔
148	.forEach (node) =>	2,358✔
149	let { hoistDec } = node	69✔
150	node.hoistDec = null	69✔
151		69✔
152	const { ancestor, child } = findAncestor node, (ancestor) =>	69✔
153	ancestor.type is "BlockStatement" and (!ancestor.bare or ancestor.root)	147✔
154		69✔
155	if ancestor	69✔
156	insertHoistDec(ancestor, child, hoistDec)	69✔
UNCOV 157	else	×
158	throw new Error("Couldn't find block to hoist declaration into.")	×
159		69✔
160	return	69✔
161		1✔
162	function insertHoistDec(block: BlockStatement, node: ASTNode \| StatementTuple, dec: ASTNode): void	69✔
163	// NOTE: This is more accurately 'statements'	69✔
164	{ expressions } := block	69✔
165	index := expressions.findIndex (exp) =>	69✔
166	exp is node or (Array.isArray(exp) and exp[1] is node)	77✔
167		69✔
168	if index < 0	69✔
UNCOV 169	throw new Error("Couldn't find expression in block for hoistable declaration.")	×
170		69✔
171	statement := [ expressions[index][0], dec, ";" ] as StatementTuple	69✔
172	expressions[index][0] = ""	69✔
173	expressions.splice index, 0, statement	69✔
174		69✔
175	// hoistDec wasn't previously a child, so now needs parent pointers	69✔
176	addParentPointers dec, block	69✔
177		1✔
178	function processBlocks(statements: StatementTuple[]): void	4,065✔
179	insertSemicolon(statements)	4,065✔
180	gatherRecursive statements, .type is "BlockStatement"	95,484✔
181	.forEach ({ expressions }) =>	4,065✔
182	processBlocks expressions	1,707✔
183		1✔
184	/**	1✔
185	* Automatic Semicolon Insertion (ASI):	1✔
186	* Avoid automatic continuation onto lines that start with	1✔
187	* certain characters by adding an explicit semicolon. See	1✔
188	* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#automatic_semicolon_insertion	1✔
189	*/	1✔
190	function insertSemicolon(statements: StatementTuple[]): void	4,065✔
191	l := statements.length	4,065✔
192	for each s, i of statements	4,065✔
193	if i < l - 1	5,374✔
194	if needsPrecedingSemicolon(statements[i + 1][1])	1,439✔
195	delim := s[2]	132✔
196	if !delim	132✔
197	s[2] = ";"	64✔
198	// If delim is an object assume it already has a semicolon	68✔
199	// TODO: trailing comments might violate this assumption	68✔
200	else if typeof delim is "string" and !delim.match(/;/)	68✔
201	s[2] = `;${delim}`	21✔
202		1✔
203	function needsPrecedingSemicolon(exp: ASTNode)	4,381✔
204	return false unless exp	4,381✔
205		4,299✔
206	if Array.isArray exp // for chained conditionals	4,381✔
207	// Recurse into first non-null element of array	1,660✔
208	for each child of exp	1,660✔
209	continue unless child?	1,856✔
210	return needsPrecedingSemicolon child	1,637✔
211	return false	23✔
212		2,639✔
213	if exp <? "string"	2,639✔
214	return /^\s*[\(\[\`\+\-\/]/.test exp	255✔
215		2,384✔
216	switch exp.type	2,384✔
217	when "ParenthesizedExpression", "ArrayExpression", "ArrowFunction", "TemplateLiteral", "RegularExpressionLiteral", "RangeExpression", "ComputedPropertyName"	77✔
218	true	77✔
219	when "AssignmentExpression"	4,381✔
220	startsWith(exp, /^(\[\|\()/)	289✔
221	when "Literal"	4,381✔
222	exp.raw?.startsWith('-') or exp.raw?.startsWith('+')	22✔
223	when "PipelineExpression", "UnwrappedExpression"	8✔
224	// skip first child which is whitespace	8✔
225	needsPrecedingSemicolon exp.children[1]	8✔
226	else	4,381✔
227	// descend into children for things like:	1,988✔
228	// IterationExpression	1,988✔
229	// CallExpression	1,988✔
230	// ParenthesizedExpression	1,988✔
231	if exp.children	1,988✔
232	needsPrecedingSemicolon exp.children	1,297✔
233		1✔
234	export {	1✔
235	blockWithPrefix	1✔
236	braceBlock	1✔
237	duplicateBlock	1✔
238	getIndent	1✔
239	hoistRefDecs	1✔
240	makeBlockFragment	1✔
241	makeEmptyBlock	1✔
242	processBlocks	1✔
243	replaceBlockExpression	1✔
244	}	1✔

DanielXMoore / Civet / 8871239985

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