#143904

Committed 09 May 2026 05:02PM UTC coverage: 97.571% (+0.008%) from 97.563%

Build # #143904

Build Type

push

Coverage Stats

585 of 658 branches covered (88.91%)

2691 of 2758 relevant lines covered (97.57%)

120.14 hits per line

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

95.16

/../lib/common/tree-traversing.js

class TreeTraversing {
  statementNotContains(node, type) {
    const statement = this.findParentStatement(node)

    if (!statement) {
      return false
    }

    const itemOfType = this.findDownType(statement, type)

    return itemOfType !== null
  }

  findParentStatement(node) {
    while (node.parent != null && !node.parent.type.includes('Statement')) {
      node = node.parent
    }

    return node.parent
  }

  findParentType(node, type) {
    while (node.parent !== undefined && node.parent.type !== type) {
      node = node.parent
    }

    return node.parent || null
  }

  findDownType(node, type) {
    if (!node || node.type === type) {
      return node
    } else {
      return null
    }
  }

  /**
   * Traverses the tree up and checks `predicate` in each node.
   *
   * @returns {boolean}
   */
  someParent(node, predicate) {
    let parent = node.parent
    while (parent) {
      if (predicate(parent)) {
        return true
      }
      parent = parent.parent
    }

    return false
  }

  *findIdentifier(ctx) {
    const children = ctx.children

    for (let i = 0; i < children.length; i += 1) {
      if (children[i].constructor.name === 'IdentifierContext') {
        yield children[i]
      }
    }

    return null
  }
}

TreeTraversing.typeOf = function typeOf(ctx) {
  if (!ctx) {
    return ''
  }

  const className = ctx.constructor.name
  const typeName = className.replace('Context', '')
  return typeName[0].toLowerCase() + typeName.substring(1)
}

TreeTraversing.hasMethodCalls = function hasMethodCalls(node, methodNames) {
  const text = node.memberName
  return methodNames.includes(text)
}

TreeTraversing.findPropertyInParents = function findPropertyInParents(node, property) {
  let curNode = node

  while (curNode !== undefined && !curNode[property]) {
    curNode = curNode.parent
  }

  return curNode && curNode[property]
}

module.exports = TreeTraversing

1	class TreeTraversing {
2	statementNotContains(node, type) {
3	const statement = this.findParentStatement(node)	2✔
4
5	if (!statement) {	2!
6	return false	×
7	}
8
9	const itemOfType = this.findDownType(statement, type)	2✔
10
11	return itemOfType !== null	2✔
12	}
13
14	findParentStatement(node) {
15	while (node.parent != null && !node.parent.type.includes('Statement')) {	2✔
16	node = node.parent	4✔
17	}
18
19	return node.parent	2✔
20	}
21
22	findParentType(node, type) {
23	while (node.parent !== undefined && node.parent.type !== type) {	473✔
24	node = node.parent	2,596✔
25	}
26
27	return node.parent \|\| null	473✔
28	}
29
30	findDownType(node, type) {
31	if (!node \|\| node.type === type) {	52✔
32	return node	1✔
33	} else {	51✔
34	return null	32✔
35	}	49✔
36	}
37		49✔
38	/**
39	* Traverses the tree up and checks `predicate` in each node.
40	*	32✔
41	* @returns {boolean}
42	*/	19✔
43	someParent(node, predicate) {
44	let parent = node.parent
45	while (parent) {
46	if (predicate(parent)) {
47	return true	18!
48	}	18✔
49	parent = parent.parent	36✔
50	}
51
52	return false	18!
53	}
54		×
55	*findIdentifier(ctx) {
56	const children = ctx.children
57
58	for (let i = 0; i < children.length; i += 1) {
59	if (children[i].constructor.name === 'IdentifierContext') {	14✔
60	yield children[i]
61	}	14✔
62	}	72✔
63		18✔
64	return null
65	}
66	}
67		14✔
68	TreeTraversing.typeOf = function typeOf(ctx) {
69	if (!ctx) {
70	return ''
71	}	1✔
72		557✔
73	const className = ctx.constructor.name	24✔
74	const typeName = className.replace('Context', '')
75	return typeName[0].toLowerCase() + typeName.substring(1)
76	}	533✔
77		533✔
78	TreeTraversing.hasMethodCalls = function hasMethodCalls(node, methodNames) {	533✔
79	const text = node.memberName
80	return methodNames.includes(text)
81	}	1✔
82		88✔
83	TreeTraversing.findPropertyInParents = function findPropertyInParents(node, property) {
84	let curNode = node	88✔
85		183✔
86	while (curNode !== undefined && !curNode[property]) {
87	curNode = curNode.parent
88	}
89		1✔
90	return curNode && curNode[property]	84✔
91	}
92		84✔
93	module.exports = TreeTraversing	535✔

protofire / solhint / #143904

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