8882682609

Committed 29 Apr 2024 05:17PM UTC coverage: 92.932% (+0.02%) from 92.916%

Build # 8882682609

Build Type

Pull #1199

github

Committed by

web-flow

Commit Message

Merge 73215b8c8 into 77d34733c

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

Run Details

2469 of 2695 branches covered (91.61%)

Branch coverage included in aggregate %.

220 of 222 new or added lines in 12 files covered. (99.1%)

1 existing line in 1 file now uncovered.

14427 of 15486 relevant lines covered (93.16%)

17579.12 hits per line

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

96.33

/source/parser/ref.civet

import type {
  ASTNode
  ASTRef
  DeclarationStatement
} from "./types.civet"

import {
  isWhitespaceOrEmpty
} from "./util.civet"

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: ASTNode, base = "ref"): ASTRef | undefined
  return unless expression? <? "object"
  if Array.isArray expression
    nonempty := [0...expression.length]
    .filter (i) => not isWhitespaceOrEmpty expression[i]
    if nonempty# is 1
      if ref := needsRef expression[nonempty[0]], base
        return ref
      return
    else
      return makeRef base
  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
  needsRef(exp, base) or exp

function makeRefAssignment(ref: ASTNode, exp: ASTNode): {
  hoistDec: DeclarationStatement
  refAssignment: ASTNode
  refAssignmentComma: ASTNode[]
}
  refAssignment :=
    type: "AssignmentExpression"
    children: [ref, " = ", exp]
  {
    hoistDec:
      type: "Declaration"
      children: ["let ", ref]
      names: []
    refAssignment
    refAssignmentComma:
      if refAssignment
        [refAssignment, ","]
      else
        []
  }

function maybeRefAssignment(exp: ASTNode, base: string = "ref"): {
  ref: ASTNode
  hoistDec?: DeclarationStatement?
  refAssignment?: ASTNode
  refAssignmentComma: ASTNode[]
}
  let hoistDec, refAssignment
  ref := maybeRef exp, base
  if ref is exp
    { ref, refAssignmentComma: [] }
  else
    { ref, ...makeRefAssignment ref, exp }

export {
  makeRef
  makeRefAssignment
  maybeRef
  maybeRefAssignment
  needsRef
}

1	import type {	1✔
2	ASTNode	1✔
3	ASTRef	1✔
4	DeclarationStatement	1✔
5	} from "./types.civet"	1✔
6		1✔
7	import {	1✔
8	isWhitespaceOrEmpty	1✔
9	} from "./util.civet"	1✔
10		1✔
11	function makeRef(base = "ref", id = base): ASTRef	1,418✔
12	return {	1,418✔
13	type: "Ref"	1,418✔
14	base	1,418✔
15	id	1,418✔
16	}	1,418✔
17		1✔
18	/**	1✔
19	* Returns a new ref if the expression needs a ref (not a simple value).	1✔
20	* Otherwise returns undefined.	1✔
21	*/	1✔
22	function needsRef(expression: ASTNode, base = "ref"): ASTRef \| undefined	218✔
23	return unless expression? <? "object"	218!
24	if Array.isArray expression	218✔
25	nonempty := [0...expression.length]	10!
26	.filter (i) => not isWhitespaceOrEmpty expression[i]	10✔
27	if nonempty# is 1	10✔
28	if ref := needsRef expression[nonempty[0]], base	3✔
29	return ref	1✔
30	return	2✔
31	else	7✔
32	return makeRef base	7✔
33	switch (expression.type) {	208✔
34	case "Ref":	218✔
35	case "Identifier":	218✔
36	case "Literal":	218✔
37	return	176✔
38	}	218✔
39	return makeRef(base)	32✔
40		1✔
41	// Transform into a ref if needed	1✔
42	function maybeRef(exp: ASTNode, base: string = "ref"): ASTNode	183✔
43	needsRef(exp, base) or exp	183✔
44		1✔
45	function makeRefAssignment(ref: ASTNode, exp: ASTNode): {	17✔
46	hoistDec: DeclarationStatement	17✔
47	refAssignment: ASTNode	17✔
48	refAssignmentComma: ASTNode[]	17✔
49	}	17✔
50	refAssignment :=	17✔
51	type: "AssignmentExpression"	17✔
52	children: [ref, " = ", exp]	17✔
53	{	17✔
54	hoistDec:	17✔
55	type: "Declaration"	17✔
56	children: ["let ", ref]	17✔
57	names: []	17✔
58	refAssignment	17✔
59	refAssignmentComma:	17✔
60	if refAssignment	17✔
61	[refAssignment, ","]	17✔
NEW 62	else	×
63	[]	17✔
64	}	17✔
65		1✔
66	function maybeRefAssignment(exp: ASTNode, base: string = "ref"): {	78✔
67	ref: ASTNode	78✔
68	hoistDec?: DeclarationStatement?	78✔
69	refAssignment?: ASTNode	78✔
70	refAssignmentComma: ASTNode[]	78✔
71	}	78✔
72	let hoistDec, refAssignment	78✔
73	ref := maybeRef exp, base	78✔
74	if ref is exp	78✔
75	{ ref, refAssignmentComma: [] }	69✔
76	else	9✔
77	{ ref, ...makeRefAssignment ref, exp }	9✔
78		1✔
79	export {	1✔
80	makeRef	1✔
81	makeRefAssignment	1✔
82	maybeRef	1✔
83	maybeRefAssignment	1✔
84	needsRef	1✔
85	}	1✔

DanielXMoore / Civet / 8882682609

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