7951947761

Committed 18 Feb 2024 09:54PM UTC coverage: 90.094% (-0.09%) from 90.179%

Build # 7951947761

Build Type

Pull #1029

github

Committed by

web-flow

Commit Message

Merge de0f36035 into df883585a

Pull Request Pull Request #1029: xor precedence above ||

Run Details

1889 of 2059 branches covered (91.74%)

Branch coverage included in aggregate %.

125 of 139 new or added lines in 6 files covered. (89.93%)

4 existing lines in 1 file now uncovered.

12844 of 14294 relevant lines covered (89.86%)

27574.87 hits per line

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

96.76

/source/parser/op.civet

import type {
  ASTNodeBase
  ASTNode
  BinaryOp
} from ./types.civet

import {
  insertTrimmingSpace
  makeLeftHandSideExpression
} from ./util.civet

// Binary operator precedence, from low to high
// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence#table
// NOTE: Added ^^ between || and &&, just like ^ is between | and &
precedenceOrder := [
  ['||', '??']
  ['^^']
  ['&&']
  ['|']
  ['^']
  ['&']
  // NOTE: Equality and inequality merged because of relational chaining
  ['==', '!=', '===', '!==',
   '<', '<=', '>', '>=', 'in', 'instanceof']
  ['<<', '>>', '>>>']
  ['+', '-']
  ['*', '/', '%']
  ['**']
]

precedenceMap := new Map
for each ops, prec of precedenceOrder
  for each op of ops
    precedenceMap.set op, prec

precedenceRelational := precedenceMap.get "=="
precedenceCustomDefault := 0.25 + precedenceMap.get "=="

function getPrecedence(op: BinaryOp): number
  // "&&" generated by expandChainedComparisons
  if typeof op === "string"
    precedenceMap.get(op) ??
    throw new Error `Unknown operator: ${op}`
  else
    precedenceMap.get(op.prec ?? op.token) ??
    if op.relational then precedenceRelational else precedenceCustomDefault

function processBinaryOpExpression($0)
  return recurse 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
  function recurse(expandedOps)
    let i = 2
    while i < expandedOps.length
      let op: BinaryOp = 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
        prec := getPrecedence op
        // left associative => `>= prec` when extending leftward
        while start >= 4 and getPrecedence(expandedOps[start - 2]) >= prec
          start -= 4
        // left associative => `> prec` when extending rightward
        while end + 4 < expandedOps.length and getPrecedence(expandedOps[end + 2]) > prec
          end += 4

        let a = start === 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 === i + 2
          ? expandedOps[i + 2]
          : recurse expandedOps.slice(i + 2, end + 1)

        // typeof shorthand: x instanceof "String" -> typeof x === "string"
        if op.token === "instanceof" and b.type === "Literal" and
           b.children?.[0]?.type === "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 === "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
        })
        i = start + 2
      else
        i += 4
    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: ASTNode)
  // 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: ASTNodeBase)
  if exp.type is "ParenthesizedExpression" and exp.implicit
    exp = exp.expression
  if exp.type is "Existence"
    return exp

function isRelationalOp(op: BinaryOp)
  op.relational or getPrecedence(op) is precedenceRelational

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

  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 getPrecedence(op) < precedenceRelational
      // end of the chain
      processChains op
      first = undefined

    i++

  processChains op if op?

  return results

  function processChains(op: BinaryOp): 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 type {	1✔
2	ASTNodeBase	1✔
3	ASTNode	1✔
4	BinaryOp	1✔
5	} from ./types.civet	1✔
6		1✔
7	import {	1✔
8	insertTrimmingSpace	1✔
9	makeLeftHandSideExpression	1✔
10	} from ./util.civet	1✔
11		1✔
12	// Binary operator precedence, from low to high	1✔
13	// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence#table	1✔
14	// NOTE: Added ^^ between \|\| and &&, just like ^ is between \| and &	1✔
15	precedenceOrder := [	1✔
16	['\|\|', '??']	1✔
17	['^^']	1✔
18	['&&']	1✔
19	['\|']	1✔
20	['^']	1✔
21	['&']	1✔
22	// NOTE: Equality and inequality merged because of relational chaining	1✔
23	['==', '!=', '===', '!==',	1✔
24	'<', '<=', '>', '>=', 'in', 'instanceof']	1✔
25	['<<', '>>', '>>>']	1✔
26	['+', '-']	1✔
27	['*', '/', '%']	1✔
28	['**']	1✔
29	]	1✔
30		1✔
31	precedenceMap := new Map	1✔
32	for each ops, prec of precedenceOrder	1✔
33	for each op of ops	11✔
34	precedenceMap.set op, prec	11✔
35		1✔
36	precedenceRelational := precedenceMap.get "=="	1✔
37	precedenceCustomDefault := 0.25 + precedenceMap.get "=="	1✔
38		1✔
39	function getPrecedence(op: BinaryOp): number	1,488✔
40	// "&&" generated by expandChainedComparisons	1,488✔
41	if typeof op === "string"	1,488✔
42	precedenceMap.get(op) ??	26✔
43	throw new Error `Unknown operator: ${op}`	26✔
44	else	1,488✔
45	precedenceMap.get(op.prec ?? op.token) ??	1,488✔
46	if op.relational then precedenceRelational else precedenceCustomDefault	1,488✔
47		1✔
48	function processBinaryOpExpression($0)	472✔
49	return recurse expandChainedComparisons($0)	472✔
UNCOV 50		×
UNCOV 51	// Expanded ops is [a, __, op1, __, b, __, op2, __, c, __, op3, __, d], etc.	×
UNCOV 52	// NOTE: all operators of higher precedence than relational have been merged into the operand expressions	×
NEW 53	function recurse(expandedOps)	✔
54	let i = 2	481✔
55	while i < expandedOps.length	481✔
56	let op: BinaryOp = expandedOps[i]	635✔
57	// a not instanceof b -> !(a instanceof b)	635✔
58	// Above is high precedence; below are relational so low precedence.	635✔
59	// a in b -> indexOf.call(b, a) >= 0	635✔
60	// a is in b -> b.includes(a)	635✔
61	// a not in b -> indexOf.call(b, a) < 0	635✔
62	// a is not in b -> !b.includes(a)	635✔
63	if op.special	635✔
64	let start = i - 2, end = i + 2	133✔
65	prec := getPrecedence op	133✔
66	// left associative => `>= prec` when extending leftward	133✔
67	while start >= 4 and getPrecedence(expandedOps[start - 2]) >= prec	133✔
68	start -= 4	8✔
69	// left associative => `> prec` when extending rightward	133✔
70	while end + 4 < expandedOps.length and getPrecedence(expandedOps[end + 2]) > prec	133✔
71	end += 4	11✔
72		133✔
73	let a = start === i - 2	133✔
74	? expandedOps[start]	133✔
75	: expandedOps.slice(start, i - 1)	133✔
76	let wsOp = expandedOps[i - 1]	133✔
77	//let op = expandedOps[i]	133✔
78	let wsB = expandedOps[i + 1]	133✔
79	let b = end === i + 2	133✔
80	? expandedOps[i + 2]	133✔
81	: recurse expandedOps.slice(i + 2, end + 1)	133✔
82		133✔
83	// typeof shorthand: x instanceof "String" -> typeof x === "string"	133✔
84	if op.token === "instanceof" and b.type === "Literal" and	133✔
85	b.children?.[0]?.type === "StringLiteral"	8✔
86	a = ["typeof ", makeLeftHandSideExpression(a)]	8✔
87	if op.negated	8✔
88	op = { ...op, token: "!==", negated: false }	3✔
89	else	8✔
90	op = { ...op, token: "===" }	8✔
91		133✔
92	if op.asConst	133✔
93	a = makeAsConst a	9✔
94	b = makeAsConst b	9✔
95		133✔
96	let children	133✔
97	if op.call	133✔
98	wsOp = insertTrimmingSpace(wsOp, "")	76✔
99		76✔
100	if op.reversed	76✔
101	wsB = insertTrimmingSpace(wsB, "")	14✔
102	children = [wsOp, op.call, "(", wsB, b, ", ", a, ")", op.suffix]	14✔
103	else	76✔
104	children = [wsOp, op.call, "(", a, ",", wsB, b, ")", op.suffix]	76✔
105	else if op.method	57✔
106	wsOp = insertTrimmingSpace(wsOp, "")	24✔
107	wsB = insertTrimmingSpace(wsB, "")	24✔
108	if op.reversed	24✔
109	if (end !== i + 2) b = makeLeftHandSideExpression b	16✔
110	b = dotNumericLiteral b	16✔
111	children = [wsB, b, wsOp, ".", op.method, "(", a, ")"]	16✔
112	else	24✔
113	if start !== i - 2 or a.type === "NumericLiteral"	24✔
NEW 114	a = makeLeftHandSideExpression a	×
115	a = dotNumericLiteral a	24✔
116	children = [a, wsOp, ".", op.method, "(", wsB, b, ")"]	24✔
117	else if op.token	33✔
118	children = [a, wsOp, op, wsB, b]	33✔
119	if (op.negated) children = ["(", ...children, ")"]	33✔
UNCOV 120	else	×
NEW 121	throw new Error("Unknown operator: " + JSON.stringify(op))	×
122	if (op.negated) children.unshift("!")	133✔
123		133✔
124	expandedOps.splice(start, end - start + 1, {	133✔
125	children	133✔
126	})	133✔
127	i = start + 2	133✔
128	else	635✔
129	i += 4	635✔
130	expandedOps	481✔
131		1✔
132	/** Add dot after numeric literal if needed for method calls. */	1✔
133	function dotNumericLiteral(literal: ASTNode)	24✔
134	if literal?.type is "Literal" and	24✔
135	/^[+-]?(?:0\|[1-9](?:_[0-9]\|[0-9])*)$/.test literal.raw	1✔
136	literal.children.push "."	1✔
137	literal.raw += "."	1✔
138	literal	24✔
139		1✔
140	const asConst =	1✔
141	ts: true,	1✔
142	children: [" as const"]	1✔
143		1✔
144	function makeAsConst(node: ASTNode)	18✔
145	// TS allows "as const" assertions for string, number, boolean, array,	18✔
146	// and object literals (and enum members), but not for null/undefined.	18✔
147	if Array.isArray(node) and node.length is 1	18✔
148	// Unwrap length-1 arrays created by expandChainedComparisons	2✔
149	node = node[0]	2✔
150	if (node.type is "Literal" and node.raw is not "null") or	18✔
151	node.type is "ArrayExpression" or node.type is "ObjectExpression"	18✔
152	{ ...node, children: [...node.children, asConst] }	5✔
153	else	18✔
154	node	18✔
155		1✔
156	function isExistence(exp: ASTNodeBase)	255✔
157	if exp.type is "ParenthesizedExpression" and exp.implicit	255✔
158	exp = exp.expression	2✔
159	if exp.type is "Existence"	255✔
160	return exp	255✔
161		1✔
162	function isRelationalOp(op: BinaryOp)	1,071✔
163	op.relational or getPrecedence(op) is precedenceRelational	1,071✔
164		1✔
165	/**	1✔
166	* binops is an array of [__, op, __, exp] tuples	1✔
167	* first is an expression	1✔
168	*/	1✔
169	function expandChainedComparisons([first, binops]: [unknown, [unknown, BinaryOp, unknown, unknown][]])	472✔
170	// TODO: add refs to ensure middle expressions are evaluated only once	472✔
171		472✔
172	results := []	472✔
173		472✔
174	i .= 0	472✔
175	l := binops.length	472✔
176		472✔
177	start .= 0	472✔
178	// indexes of chainable ops	472✔
179	chains .= []	472✔
180	let op	472✔
181		472✔
182	while i < l	472✔
183	([, op] = binops[i])	599✔
184		599✔
185	// NOTE: Treat Coffee `in` and `not in` ops as relational.	599✔
186	if isRelationalOp op	599✔
187	chains.push i	262✔
188	else if getPrecedence(op) < precedenceRelational	337✔
189	// end of the chain	89✔
190	processChains op	89✔
191	first = undefined	89✔
192		599✔
193	i++	599✔
194		472✔
195	processChains op if op?	472✔
196		472✔
197	return results	472✔
198		472✔
199	function processChains(op: BinaryOp): void	472✔
200	if first and isRelationalOp op	561✔
201	first = expandExistence first	194✔
202		561✔
203	if chains.length > 1	561✔
204	chains.forEach (index, k) =>	27✔
205	if (k > 0) {	61✔
206	// NOTE: Inserting ws tokens to keep even operator spacing in the resulting array	34✔
207	results.push(" ", "&&", " ")	34✔
208	}	34✔
209		61✔
210	binop := binops[index]	61✔
211	[ , , , exp] .= binop	61✔
212	exp = binop[3] = expandExistence(exp)	61✔
213		61✔
214	let endIndex	61✔
215	if (k < chains.length - 1) {	61✔
216	endIndex = chains[k + 1]	34✔
217	} else {	61✔
218	endIndex = i + 1	27✔
219	}	27✔
220		61✔
221	results.push(first, ...binops.slice(start, endIndex).flat())	61✔
222	first = [exp].concat(binops.slice(index + 1, endIndex))	61✔
223	start = endIndex	61✔
224	else	534✔
225	// Advance start if there was no chain	534✔
226	results.push first if first	534✔
227	results.push ...binops[start...i + 1].flat()	534✔
228	start = i + 1	534✔
229		561✔
230	chains.length = 0	561✔
231		472✔
232	function expandExistence(exp)	472✔
233	// Expand existence operator like x?	255✔
234	const existence = isExistence(exp)	255✔
235	if existence	255✔
236	results.push(existence, " ", "&&", " ")	2✔
237	return existence.expression	2✔
238		253✔
239	return exp	253✔
240	;	472✔
241		1✔
242	export {	1✔
243	processBinaryOpExpression	1✔
244	}	1✔

DanielXMoore / Civet / 7951947761

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