7951509997

Committed 18 Feb 2024 08:24PM UTC coverage: 90.189% (-1.2%) from 91.429%

Build # 7951509997

Build Type

Pull #1026

github

Committed by

web-flow

Commit Message

Merge da5398fdf into 6bd3df1bf

Pull Request Pull Request #1026: Split lib.civet into many files

Run Details

1891 of 2061 branches covered (91.75%)

Branch coverage included in aggregate %.

4288 of 4633 new or added lines in 16 files covered. (92.55%)

13 existing lines in 1 file now uncovered.

12836 of 14268 relevant lines covered (89.96%)

27554.48 hits per line

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

98.34

/source/parser/op.civet

import {
  ASTNode
} from ./types.civet

import {
  insertTrimmingSpace
  makeLeftHandSideExpression
} from ./util.civet

function processBinaryOpExpression($0)
  expandedOps := expandChainedComparisons($0)

  // Expanded ops is [a, __, op1, __, b, __, op2, __, c, __, op3, __, d], etc.
  // NOTE: all operators of higher precedence than relational have been merged into the operand expressions
  let i = 2
  while (i < expandedOps.length) {
    let op = expandedOps[i]
    // a not instanceof b -> !(a instanceof b)
    // Above is high precedence; below are relational so low precedence.
    // a in b -> indexOf.call(b, a) >= 0
    // a is in b -> b.includes(a)
    // a not in b -> indexOf.call(b, a) < 0
    // a is not in b -> !b.includes(a)
    if (op.special) {
      let start = i - 2, end = i + 2
      if (isRelationalOp(op)) {
        while (start >= 4 and !isLowerThanRelationalOp(expandedOps[start - 2])) {
          start -= 4
        }
        while (end + 4 < expandedOps.length and !isLowerThanRelationalOp(expandedOps[end + 2])) {
          end += 4
        }
      }

      let a = start is i - 2
        ? expandedOps[start]
        : expandedOps.slice(start, i - 1)
      let wsOp = expandedOps[i - 1]
      //let op = expandedOps[i]
      let wsB = expandedOps[i + 1]
      let b = end is i + 2
        ? expandedOps[i + 2]
        : expandedOps.slice(i + 2, end + 1)

      // typeof shorthand: x instanceof "String" -> typeof x is "string"
      if (op.token is "instanceof" and b.type is "Literal" &&
        b.children?.[0]?.type is "StringLiteral") {
        a = ["typeof ", makeLeftHandSideExpression(a)]
        if (op.negated) {
          op = { ...op, token: "!==", negated: false }
        } else {
          op = { ...op, token: "===" }
        }
      }

      if (op.asConst) {
        a = makeAsConst(a)
        b = makeAsConst(b)
      }

      let children
      if (op.call) {
        wsOp = insertTrimmingSpace(wsOp, "")

        if (op.reversed) {
          wsB = insertTrimmingSpace(wsB, "")
          children = [wsOp, op.call, "(", wsB, b, ", ", a, ")", op.suffix]
        } else {
          children = [wsOp, op.call, "(", a, ",", wsB, b, ")", op.suffix]
        }
      } else if (op.method) {
        wsOp = insertTrimmingSpace(wsOp, "")
        wsB = insertTrimmingSpace(wsB, "")
        if op.reversed
          if (end !== i + 2) b = makeLeftHandSideExpression b
          b = dotNumericLiteral b
          children = [wsB, b, wsOp, ".", op.method, "(", a, ")"]
        else
          if start !== i - 2 or a.type is "NumericLiteral"
            a = makeLeftHandSideExpression a
          a = dotNumericLiteral a
          children = [a, wsOp, ".", op.method, "(", wsB, b, ")"]
      } else if (op.token) {
        children = [a, wsOp, op, wsB, b]
        if (op.negated) children = ["(", ...children, ")"]
      } else {
        throw new Error("Unknown operator: " + JSON.stringify(op))
      }
      if (op.negated) children.unshift("!")

      expandedOps.splice(start, end - start + 1, {
        children
      })
    } else {
      i += 4
    }
  }

  return expandedOps

/** Add dot after numeric literal if needed for method calls. */
function dotNumericLiteral(literal: ASTNode)
  if literal?.type is "Literal" and
     /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test literal.raw
    literal.children.push "."
    literal.raw += "."
  literal

const asConst =
  ts: true,
  children: [" as const"]

function makeAsConst(node)
  // TS allows "as const" assertions for string, number, boolean, array,
  // and object literals (and enum members), but not for null/undefined.
  if Array.isArray(node) and node.length is 1
    // Unwrap length-1 arrays created by expandChainedComparisons
    node = node[0]
  if (node.type is "Literal" and node.raw is not "null") or
      node.type is "ArrayExpression" or node.type is "ObjectExpression"
    { ...node, children: [...node.children, asConst] }
  else
    node

function isExistence(exp) {
  if (exp.type is "ParenthesizedExpression" and exp.implicit) {
    exp = exp.expression
  }
  if (exp.type is "Existence") {
    return exp
  }
}

// all relational operators could be chained in theory, including in and instanceof
relationalOps := ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"]

function isRelationalOp(op)
  relationalOps.includes(op.token) or op.relational

// lower precedence than comparisons, but ignoring assignments and comma
// which are handled separately
lowerThanRelationalOps := ["&", "^", "|", "&&", "||", "??"]

function isLowerThanRelationalOp(op)
  // "&&" without wrapper is generated by expandedChainedComparisons
  op is "&&" or lowerThanRelationalOps.includes(op.token) or isRelationalOp(op)

/**
* binops is an array of [__, op, __, exp] tuples
* first is an expression
*/
function expandChainedComparisons([first, binops]: [unknown, [unknown, ASTLeaf, unknown, unknown][]])
  // TODO: add refs to ensure middle expressions are evaluated only once

  // short circuit/bitwise ops have lower precedence than comparison ops
  // so we only need to look for chains in the sections between them
  lowerPrecedenceOps := ["??", "&&", "||", "&", "|", "^"]

  // shift/arithmetic ops have higher precedence, they will bind to expressions inside the chains
  // const higherPrecedenceOps = ["<<", ">>", ">>>", "+", "-", "*", "**", "/", "%"]

  results := []

  i .= 0
  l := binops.length

  start .= 0
  // indexes of chainable ops
  chains .= []
  let op

  while i < l
    ([, op] = binops[i])

    // NOTE: Treat Coffee `in` and `not in` ops as relational.
    if isRelationalOp op
      chains.push i
    else if lowerPrecedenceOps.includes op.token
      // end of the chain
      processChains op
      first = undefined

    i++

  processChains op

  return results

  function processChains(op): void
    if first and isRelationalOp op
      first = expandExistence first

    if chains.length > 1
      chains.forEach (index, k) =>
        if (k > 0) {
          // NOTE: Inserting ws tokens to keep even operator spacing in the resulting array
          results.push(" ", "&&", " ")
        }

        binop := binops[index]
        [ , , , exp] .= binop
        exp = binop[3] = expandExistence(exp)

        let endIndex
        if (k < chains.length - 1) {
          endIndex = chains[k + 1]
        } else {
          endIndex = i + 1
        }

        results.push(first, ...binops.slice(start, endIndex).flat())
        first = [exp].concat(binops.slice(index + 1, endIndex))
        start = endIndex
    else
      // Advance start if there was no chain
      results.push first if first
      results.push ...binops[start...i + 1].flat()
      start = i + 1

    chains.length = 0

  function expandExistence(exp)
    // Expand existence operator like x?
    const existence = isExistence(exp)
    if existence
      results.push(existence, " ", "&&", " ")
      return existence.expression

    return exp
  ;

export {
  processBinaryOpExpression
}

1	import {	1✔
2	ASTNode	1✔
3	} from ./types.civet	1✔
4		1✔
5	import {	1✔
6	insertTrimmingSpace	1✔
7	makeLeftHandSideExpression	1✔
8	} from ./util.civet	1✔
9		1✔
10	function processBinaryOpExpression($0)	466✔
11	expandedOps := expandChainedComparisons($0)	466✔
12		466✔
13	// Expanded ops is [a, __, op1, __, b, __, op2, __, c, __, op3, __, d], etc.	466✔
14	// NOTE: all operators of higher precedence than relational have been merged into the operand expressions	466✔
15	let i = 2	466✔
16	while (i < expandedOps.length) {	466✔
17	let op = expandedOps[i]	605✔
18	// a not instanceof b -> !(a instanceof b)	605✔
19	// Above is high precedence; below are relational so low precedence.	605✔
20	// a in b -> indexOf.call(b, a) >= 0	605✔
21	// a is in b -> b.includes(a)	605✔
22	// a not in b -> indexOf.call(b, a) < 0	605✔
23	// a is not in b -> !b.includes(a)	605✔
24	if (op.special) {	605✔
25	let start = i - 2, end = i + 2	123✔
26	if (isRelationalOp(op)) {	123✔
27	while (start >= 4 and !isLowerThanRelationalOp(expandedOps[start - 2])) {	70✔
28	start -= 4	3✔
29	}	3✔
30	while (end + 4 < expandedOps.length and !isLowerThanRelationalOp(expandedOps[end + 2])) {	70✔
31	end += 4	6✔
32	}	6✔
33	}	70✔
34		123✔
35	let a = start is i - 2	123✔
36	? expandedOps[start]	123✔
37	: expandedOps.slice(start, i - 1)	123✔
38	let wsOp = expandedOps[i - 1]	123✔
39	//let op = expandedOps[i]	123✔
40	let wsB = expandedOps[i + 1]	123✔
41	let b = end is i + 2	123✔
42	? expandedOps[i + 2]	123✔
43	: expandedOps.slice(i + 2, end + 1)	123✔
44		123✔
45	// typeof shorthand: x instanceof "String" -> typeof x is "string"	123✔
46	if (op.token is "instanceof" and b.type is "Literal" &&	123✔
47	b.children?.[0]?.type is "StringLiteral") {	123✔
48	a = ["typeof ", makeLeftHandSideExpression(a)]	8✔
49	if (op.negated) {	8✔
50	op = { ...op, token: "!==", negated: false }	3✔
51	} else {	8✔
52	op = { ...op, token: "===" }	5✔
53	}	5✔
54	}	8✔
55		123✔
56	if (op.asConst) {	123✔
57	a = makeAsConst(a)	9✔
58	b = makeAsConst(b)	9✔
59	}	9✔
60		123✔
61	let children	123✔
62	if (op.call) {	123✔
63	wsOp = insertTrimmingSpace(wsOp, "")	70✔
64		70✔
65	if (op.reversed) {	70✔
66	wsB = insertTrimmingSpace(wsB, "")	14✔
67	children = [wsOp, op.call, "(", wsB, b, ", ", a, ")", op.suffix]	14✔
68	} else {	70✔
69	children = [wsOp, op.call, "(", a, ",", wsB, b, ")", op.suffix]	56✔
70	}	56✔
71	} else if (op.method) {	123✔
72	wsOp = insertTrimmingSpace(wsOp, "")	20✔
73	wsB = insertTrimmingSpace(wsB, "")	20✔
74	if op.reversed	20✔
75	if (end !== i + 2) b = makeLeftHandSideExpression b	12✔
76	b = dotNumericLiteral b	12✔
77	children = [wsB, b, wsOp, ".", op.method, "(", a, ")"]	12✔
78	else	8✔
79	if start !== i - 2 or a.type is "NumericLiteral"	8✔
NEW 80	a = makeLeftHandSideExpression a	×
81	a = dotNumericLiteral a	8✔
82	children = [a, wsOp, ".", op.method, "(", wsB, b, ")"]	8✔
83	} else if (op.token) {	53✔
84	children = [a, wsOp, op, wsB, b]	33✔
85	if (op.negated) children = ["(", ...children, ")"]	33✔
86	} else {	33!
NEW 87	throw new Error("Unknown operator: " + JSON.stringify(op))	×
NEW 88	}	×
89	if (op.negated) children.unshift("!")	123✔
90		123✔
91	expandedOps.splice(start, end - start + 1, {	123✔
92	children	123✔
93	})	123✔
94	} else {	605✔
95	i += 4	482✔
96	}	482✔
97	}	605✔
98		466✔
99	return expandedOps	466✔
100		1✔
101	/** Add dot after numeric literal if needed for method calls. */	1✔
102	function dotNumericLiteral(literal: ASTNode)	20✔
103	if literal?.type is "Literal" and	20✔
104	/^[+-]?(?:0\|[1-9](?:_[0-9]\|[0-9])*)$/.test literal.raw	1✔
105	literal.children.push "."	1✔
106	literal.raw += "."	1✔
107	literal	20✔
108		1✔
109	const asConst =	1✔
110	ts: true,	1✔
111	children: [" as const"]	1✔
112		1✔
113	function makeAsConst(node)	18✔
114	// TS allows "as const" assertions for string, number, boolean, array,	18✔
115	// and object literals (and enum members), but not for null/undefined.	18✔
116	if Array.isArray(node) and node.length is 1	18✔
117	// Unwrap length-1 arrays created by expandChainedComparisons	2✔
118	node = node[0]	2✔
119	if (node.type is "Literal" and node.raw is not "null") or	18✔
120	node.type is "ArrayExpression" or node.type is "ObjectExpression"	18✔
121	{ ...node, children: [...node.children, asConst] }	5✔
122	else	18✔
123	node	18✔
124		1✔
125	function isExistence(exp) {	252✔
126	if (exp.type is "ParenthesizedExpression" and exp.implicit) {	252✔
127	exp = exp.expression	2✔
128	}	2✔
129	if (exp.type is "Existence") {	252✔
130	return exp	252✔
131	}	252✔
132	}	252✔
133		1✔
134	// all relational operators could be chained in theory, including in and instanceof	1✔
135	relationalOps := ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"]	1✔
136		1✔
137	function isRelationalOp(op)	1,176✔
138	relationalOps.includes(op.token) or op.relational	1,176✔
139		1✔
140	// lower precedence than comparisons, but ignoring assignments and comma	1✔
141	// which are handled separately	1✔
142	lowerThanRelationalOps := ["&", "^", "\|", "&&", "\|\|", "??"]	1✔
143		1✔
144	function isLowerThanRelationalOp(op)	37✔
145	// "&&" without wrapper is generated by expandedChainedComparisons	37✔
146	op is "&&" or lowerThanRelationalOps.includes(op.token) or isRelationalOp(op)	37✔
147		1✔
148	/**	1✔
149	* binops is an array of [__, op, __, exp] tuples	1✔
150	* first is an expression	1✔
151	*/	1✔
152	function expandChainedComparisons([first, binops]: [unknown, [unknown, ASTLeaf, unknown, unknown][]])	466✔
153	// TODO: add refs to ensure middle expressions are evaluated only once	466✔
154		466✔
155	// short circuit/bitwise ops have lower precedence than comparison ops	466✔
156	// so we only need to look for chains in the sections between them	466✔
157	lowerPrecedenceOps := ["??", "&&", "\|\|", "&", "\|", "^"]	466✔
158		466✔
159	// shift/arithmetic ops have higher precedence, they will bind to expressions inside the chains	466✔
160	// const higherPrecedenceOps = ["<<", ">>", ">>>", "+", "-", "", "*", "/", "%"]	466✔
161		466✔
162	results := []	466✔
163		466✔
164	i .= 0	466✔
165	l := binops.length	466✔
166		466✔
167	start .= 0	466✔
168	// indexes of chainable ops	466✔
169	chains .= []	466✔
170	let op	466✔
171		466✔
172	while i < l	466✔
173	([, op] = binops[i])	578✔
174		578✔
175	// NOTE: Treat Coffee `in` and `not in` ops as relational.	578✔
176	if isRelationalOp op	578✔
177	chains.push i	255✔
178	else if lowerPrecedenceOps.includes op.token	323✔
179	// end of the chain	61✔
180	processChains op	61✔
181	first = undefined	61✔
182		578✔
183	i++	578✔
184		466✔
185	processChains op	466✔
186		466✔
187	return results	466✔
188		466✔
189	function processChains(op): void	466✔
190	if first and isRelationalOp op	527✔
191	first = expandExistence first	193✔
192		527✔
193	if chains.length > 1	527✔
194	chains.forEach (index, k) =>	26✔
195	if (k > 0) {	59✔
196	// NOTE: Inserting ws tokens to keep even operator spacing in the resulting array	33✔
197	results.push(" ", "&&", " ")	33✔
198	}	33✔
199		59✔
200	binop := binops[index]	59✔
201	[ , , , exp] .= binop	59✔
202	exp = binop[3] = expandExistence(exp)	59✔
203		59✔
204	let endIndex	59✔
205	if (k < chains.length - 1) {	59✔
206	endIndex = chains[k + 1]	33✔
207	} else {	59✔
208	endIndex = i + 1	26✔
209	}	26✔
210		59✔
211	results.push(first, ...binops.slice(start, endIndex).flat())	59✔
212	first = [exp].concat(binops.slice(index + 1, endIndex))	59✔
213	start = endIndex	59✔
214	else	501✔
215	// Advance start if there was no chain	501✔
216	results.push first if first	501✔
217	results.push ...binops[start...i + 1].flat()	501✔
218	start = i + 1	501✔
219		527✔
220	chains.length = 0	527✔
221		466✔
222	function expandExistence(exp)	466✔
223	// Expand existence operator like x?	252✔
224	const existence = isExistence(exp)	252✔
225	if existence	252✔
226	results.push(existence, " ", "&&", " ")	2✔
227	return existence.expression	2✔
228		250✔
229	return exp	250✔
230	;	466✔
231		1✔
232	export {	1✔
233	processBinaryOpExpression	1✔
234	}	1✔

DanielXMoore / Civet / 7951509997

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