devtools-tracing 1.0.0

package/lib/front_end/core/sdk/CSSPropertyParser.ts

@@ -0,0 +1,681 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import type * as Platform from '../../core/platform/platform.js';
+import * as CodeMirror from '../../third_party/codemirror.next/codemirror.next.js';
+
+import {TextMatcher} from './CSSPropertyParserMatchers.js';
+
+const globalValues = new Set<string>(['inherit', 'initial', 'unset']);
+
+const tagRegexp = /[\x20-\x7E]{4}/;
+const numRegexp = /[+-]?(?:\d*\.)?\d+(?:[eE]\d+)?/;
+const fontVariationSettingsRegexp =
+    new RegExp(`(?:'(${tagRegexp.source})')|(?:"(${tagRegexp.source})")\\s+(${numRegexp.source})`);
+
+/**
+ * Extracts information about font variation settings assuming
+ * value is valid according to the spec: https://drafts.csswg.org/css-fonts-4/#font-variation-settings-def
+ */
+export function parseFontVariationSettings(value: string): Array<{
+  tag: string,
+  value: number,
+}> {
+  if (globalValues.has(value.trim()) || value.trim() === 'normal') {
+    return [];
+  }
+  const results = [];
+  for (const setting of splitByComma(stripComments(value))) {
+    const match = setting.match(fontVariationSettingsRegexp);
+    if (match) {
+      results.push({
+        tag: match[1] || match[2],
+        value: parseFloat(match[3]),
+      });
+    }
+  }
+  return results;
+}
+
+// "str" or 'str'
+const fontFamilyRegexp = /^"(.+)"|'(.+)'$/;
+
+/**
+ * Extracts font families assuming the value is valid according to
+ * the spec: https://drafts.csswg.org/css-fonts-4/#font-family-prop
+ */
+export function parseFontFamily(value: string): string[] {
+  if (globalValues.has(value.trim())) {
+    return [];
+  }
+  const results = [];
+  for (const family of splitByComma(stripComments(value))) {
+    const match = family.match(fontFamilyRegexp);
+    if (match) {
+      // Either the 1st or 2nd group matches if the value is in quotes
+      results.push(match[1] || match[2]);
+    } else {
+      // Value without without quotes.
+      results.push(family);
+    }
+  }
+  return results;
+}
+
+/**
+ * Splits a list of values by comma and trims parts
+ */
+export function splitByComma(value: string): string[] {
+  return value.split(',').map(part => part.trim());
+}
+
+export function stripComments(value: string): string {
+  return value.replaceAll(/(\/\*(?:.|\s)*?\*\/)/g, '');
+}
+
+function nodeText(node: CodeMirror.SyntaxNode, text: string): string {
+  return nodeTextRange(node, node, text);
+}
+function nodeTextRange(from: CodeMirror.SyntaxNode, to: CodeMirror.SyntaxNode, text: string): string {
+  return text.substring(from.from, to.to);
+}
+
+export class SyntaxTree {
+  readonly propertyValue: string;
+  readonly rule: string;
+  readonly tree: CodeMirror.SyntaxNode;
+  readonly trailingNodes: CodeMirror.SyntaxNode[];
+  readonly propertyName: string|undefined;
+  constructor(
+      propertyValue: string, rule: string, tree: CodeMirror.SyntaxNode, propertyName?: string,
+      trailingNodes: CodeMirror.SyntaxNode[] = []) {
+    this.propertyName = propertyName;
+    this.propertyValue = propertyValue;
+    this.rule = rule;
+    this.tree = tree;
+    this.trailingNodes = trailingNodes;
+  }
+
+  text(node?: CodeMirror.SyntaxNode|null): string {
+    if (node === null) {
+      return '';
+    }
+    return nodeText(node ?? this.tree, this.rule);
+  }
+
+  textRange(from: CodeMirror.SyntaxNode|undefined, to: CodeMirror.SyntaxNode|undefined): string {
+    if (!from || !to) {
+      return '';
+    }
+    return nodeTextRange(from, to, this.rule);
+  }
+
+  subtree(node: CodeMirror.SyntaxNode): SyntaxTree {
+    return new SyntaxTree(this.propertyValue, this.rule, node);
+  }
+}
+
+export interface SyntaxNodeRef {
+  node: CodeMirror.SyntaxNode;
+}
+
+export abstract class TreeWalker {
+  readonly ast: SyntaxTree;
+  constructor(ast: SyntaxTree) {
+    this.ast = ast;
+  }
+  static walkExcludingSuccessors<T extends TreeWalker, ArgTs extends unknown[]>(
+      this: {new(ast: SyntaxTree, ...args: ArgTs): T}, propertyValue: SyntaxTree, ...args: ArgTs): T {
+    const instance = new this(propertyValue, ...args);
+    if (propertyValue.tree.name === 'Declaration') {
+      instance.iterateDeclaration(propertyValue.tree);
+    } else {
+      instance.iterateExcludingSuccessors(propertyValue.tree);
+    }
+    return instance;
+  }
+  static walk<T extends TreeWalker, ArgTs extends unknown[]>(
+      this: {new(ast: SyntaxTree, ...args: ArgTs): T}, propertyValue: SyntaxTree, ...args: ArgTs): T {
+    const instance = new this(propertyValue, ...args);
+    if (propertyValue.tree.name === 'Declaration') {
+      instance.iterateDeclaration(propertyValue.tree);
+    } else {
+      instance.iterate(propertyValue.tree);
+    }
+    return instance;
+  }
+
+  iterateDeclaration(tree: CodeMirror.SyntaxNode): void {
+    if (tree.name !== 'Declaration') {
+      return;
+    }
+    if (this.enter(tree)) {
+      for (const sibling of ASTUtils.siblings(ASTUtils.declValue(tree))) {
+        sibling.cursor().iterate(this.enter.bind(this), this.leave.bind(this));
+      }
+    }
+    this.leave(tree);
+  }
+
+  protected iterate(tree: CodeMirror.SyntaxNode): void {
+    // Includes siblings of tree.
+    for (const sibling of ASTUtils.siblings(tree)) {
+      sibling.cursor().iterate(this.enter.bind(this), this.leave.bind(this));
+    }
+  }
+
+  protected iterateExcludingSuccessors(tree: CodeMirror.SyntaxNode): void {
+    tree.cursor().iterate(this.enter.bind(this), this.leave.bind(this));
+  }
+
+  protected enter(_node: SyntaxNodeRef): boolean {
+    return true;
+  }
+
+  protected leave(_node: SyntaxNodeRef): void {
+  }
+}
+
+export interface Match {
+  readonly text: string;
+  readonly node: CodeMirror.SyntaxNode;
+  computedText?(): string|null;
+}
+
+export interface Matcher<MatchT extends Match> {
+  readonly matchType: Platform.Constructor.ConstructorOrAbstract<MatchT>;
+  accepts(propertyName: string): boolean;
+  matches(node: CodeMirror.SyntaxNode, matching: BottomUpTreeMatching): MatchT|null;
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function matcherBase<MatchT extends Match>(matchT: Platform.Constructor.ConstructorOrAbstract<MatchT>) {
+  class MatcherBase implements Matcher<MatchT> {
+    matchType = matchT;
+    accepts(_propertyName: string): boolean {
+      return true;
+    }
+
+    matches(_node: CodeMirror.SyntaxNode, _matching: BottomUpTreeMatching): MatchT|null {
+      return null;
+    }
+  }
+  return MatcherBase;
+}
+
+type MatchKey = Platform.Brand.Brand<string, 'MatchKey'>;
+export class BottomUpTreeMatching extends TreeWalker {
+  readonly #matchers: Array<Matcher<Match>> = [];
+  readonly #matchedNodes = new Map<MatchKey, Match>();
+  readonly computedText: ComputedText;
+
+  #key(node: CodeMirror.SyntaxNode): MatchKey {
+    return `${node.from}:${node.to}` as MatchKey;
+  }
+
+  constructor(ast: SyntaxTree, matchers: Array<Matcher<Match>>) {
+    super(ast);
+    this.computedText = new ComputedText(ast.rule.substring(ast.tree.from));
+    this.#matchers.push(...matchers.filter(m => !ast.propertyName || m.accepts(ast.propertyName)));
+    this.#matchers.push(new TextMatcher());
+  }
+
+  protected override leave({node}: SyntaxNodeRef): void {
+    for (const matcher of this.#matchers) {
+      const match = matcher.matches(node, this);
+      if (match) {
+        this.computedText.push(match, node.from - this.ast.tree.from);
+        this.#matchedNodes.set(this.#key(node), match);
+        break;
+      }
+    }
+  }
+
+  matchText(node: CodeMirror.SyntaxNode): void {
+    const matchers = this.#matchers.splice(0);
+    this.#matchers.push(new TextMatcher());
+    this.iterateExcludingSuccessors(node);
+    this.#matchers.push(...matchers);
+  }
+
+  hasMatches(...matchTypes: Array<Platform.Constructor.Constructor<Match>>): boolean {
+    return Boolean(this.#matchedNodes.values().find(match => matchTypes.some(matchType => match instanceof matchType)));
+  }
+
+  getMatch(node: CodeMirror.SyntaxNode): Match|undefined {
+    return this.#matchedNodes.get(this.#key(node));
+  }
+
+  hasUnresolvedSubstitutions(node: CodeMirror.SyntaxNode): boolean {
+    return this.hasUnresolvedSubstitutionsRange(node, node);
+  }
+
+  hasUnresolvedSubstitutionsRange(from: CodeMirror.SyntaxNode, to: CodeMirror.SyntaxNode): boolean {
+    return this.computedText.hasUnresolvedSubstitutions(from.from - this.ast.tree.from, to.to - this.ast.tree.from);
+  }
+
+  getComputedText(node: CodeMirror.SyntaxNode, substitutionHook?: (match: Match) => string | null): string {
+    return this.getComputedTextRange(node, node, substitutionHook);
+  }
+
+  getLonghandValuesCount(): number {
+    const [from, to] = ASTUtils.range(ASTUtils.siblings(ASTUtils.declValue(this.ast.tree)));
+    if (!from || !to) {
+      return 0;
+    }
+    return this.computedText.countTopLevelValues(from.from - this.ast.tree.from, to.to - this.ast.tree.from);
+  }
+
+  getComputedLonghandName(to: CodeMirror.SyntaxNode): number {
+    const from = ASTUtils.declValue(this.ast.tree) ?? this.ast.tree;
+    return this.computedText.countTopLevelValues(from.from - this.ast.tree.from, to.from - this.ast.tree.from);
+  }
+
+  getComputedPropertyValueText(substitutionHook?: (match: Match) => string | null): string {
+    const [from, to] = ASTUtils.range(ASTUtils.siblings(ASTUtils.declValue(this.ast.tree)));
+    return this.getComputedTextRange(from ?? this.ast.tree, to ?? this.ast.tree, substitutionHook);
+  }
+
+  getComputedTextRange(
+      from: CodeMirror.SyntaxNode|undefined, to: CodeMirror.SyntaxNode|undefined,
+      substitutionHook?: (match: Match) => string | null): string {
+    if (!from || !to) {
+      return '';
+    }
+    return this.computedText.get(from.from - this.ast.tree.from, to.to - this.ast.tree.from, substitutionHook);
+  }
+}
+
+type MatchWithComputedText = Match&{computedText: NonNullable<Match['computedText']>};
+class ComputedTextChunk {
+  #cachedComputedText: string|null = null;
+  #topLevelValueCount: number|null = null;
+  constructor(readonly match: MatchWithComputedText, readonly offset: number) {
+  }
+
+  get end(): number {
+    return this.offset + this.length;
+  }
+
+  get length(): number {
+    return this.match.text.length;
+  }
+
+  get computedText(): string|null {
+    if (this.#cachedComputedText === null) {
+      this.#cachedComputedText = this.match.computedText();
+    }
+    return this.#cachedComputedText;
+  }
+
+  // If the match is top-level, i.e. is an outermost sub-expression in the property value, count the number of outermost
+  // sub-expressions after applying any potential substitutions.
+  get topLevelValueCount(): number {
+    if (this.match.node.parent?.name !== 'Declaration') {
+      // Not a top-level match.
+      return 0;
+    }
+    const computedText = this.computedText;
+    if (computedText === '') {
+      // Substitutions elided the match altogether.
+      return 0;
+    }
+    if (this.#topLevelValueCount === null) {
+      // computedText may be null, in which case the match text was not replaced.
+      this.#topLevelValueCount =
+          ASTUtils
+              .siblings(ASTUtils.declValue(tokenizeDeclaration('--p', computedText ?? this.match.text)?.tree ?? null))
+              .length;
+    }
+    return this.#topLevelValueCount;
+  }
+}
+
+/**
+ * This class constructs the "computed" text from the input property text, i.e., it will strip comments and substitute
+ * var() functions if possible. It's intended for use during the bottom-up tree matching process. The original text is
+ * not modified. Instead, computed text slices are produced on the fly. During bottom-up matching, the sequence of
+ * top-level comments and var() matches will be recorded. This produces an ordered sequence of text pieces that need to
+ * be substituted into the original text. When a computed text slice is requested, it is generated by piecing together
+ * original and computed slices as required.
+ **/
+export class ComputedText {
+  readonly #chunks: ComputedTextChunk[] = [];
+  readonly text: string;
+  readonly #topLevelValueCounts = new Map<string, number>();
+
+  #sorted = true;
+  constructor(text: string) {
+    this.text = text;
+  }
+
+  clear(): void {
+    this.#chunks.splice(0);
+    this.#topLevelValueCounts.clear();
+  }
+
+  get chunkCount(): number {
+    return this.#chunks.length;
+  }
+
+  #sortIfNecessary(): void {
+    if (this.#sorted) {
+      return;
+    }
+    // Sort intervals by offset, with longer intervals first if the offset is identical.
+    this.#chunks.sort((a, b) => {
+      if (a.offset < b.offset) {
+        return -1;
+      }
+      if (b.offset < a.offset) {
+        return 1;
+      }
+      if (a.end > b.end) {
+        return -1;
+      }
+      if (a.end < b.end) {
+        return 1;
+      }
+      return 0;
+    });
+    this.#sorted = true;
+  }
+
+  // Add another substitutable match. The match will either be appended to the list of existing matches or it will
+  // be substituted for the last match(es) if it encompasses them.
+  push(match: Match, offset: number): void {
+    function hasComputedText(match: Match): match is MatchWithComputedText {
+      return Boolean(match.computedText);
+    }
+    if (!hasComputedText(match) || offset < 0 || offset >= this.text.length) {
+      return;
+    }
+    const chunk = new ComputedTextChunk(match, offset);
+    if (chunk.end > this.text.length) {
+      return;
+    }
+    this.#sorted = false;
+    this.#chunks.push(chunk);
+  }
+
+  * #range(begin: number, end: number): Generator<ComputedTextChunk> {
+    this.#sortIfNecessary();
+    let i = this.#chunks.findIndex(c => c.offset >= begin);
+    while (i >= 0 && i < this.#chunks.length && this.#chunks[i].end > begin && begin < end) {
+      if (this.#chunks[i].end > end) {
+        i++;
+        continue;
+      }
+      yield this.#chunks[i];
+      begin = this.#chunks[i].end;
+      while (begin < end && i < this.#chunks.length && this.#chunks[i].offset < begin) {
+        i++;
+      }
+    }
+  }
+
+  hasUnresolvedSubstitutions(begin: number, end: number): boolean {
+    for (const chunk of this.#range(begin, end)) {
+      if (chunk.computedText === null) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  * #getPieces(begin: number, end: number): Generator<string|ComputedTextChunk> {
+    for (const chunk of this.#range(begin, end)) {
+      const piece = this.text.substring(begin, Math.min(chunk.offset, end));
+      yield piece;
+      if (end >= chunk.end) {
+        yield chunk;
+      }
+      begin = chunk.end;
+    }
+    if (begin < end) {
+      const piece = this.text.substring(begin, end);
+      yield piece;
+    }
+  }
+
+  // Get a slice of the computed text corresponding to the property text in the range [begin, end). The slice may not
+  // start within a substitution chunk, e.g., it's invalid to request the computed text for the property value text
+  // slice "1px var(--".
+  get(begin: number, end: number, substitutionHook?: (match: Match) => string | null): string {
+    const pieces: string[] = [];
+    const getText = (piece: string|ComputedTextChunk): string => {
+      if (typeof piece === 'string') {
+        return piece;
+      }
+      const substitution = substitutionHook?.(piece.match) ?? null;
+      if (substitution !== null) {
+        return getText(substitution);
+      }
+      return piece.computedText ?? piece.match.text;
+    };
+
+    for (const piece of this.#getPieces(begin, end)) {
+      const text = getText(piece);
+      if (text.length === 0) {
+        continue;
+      }
+      if (pieces.length > 0 && requiresSpace(pieces[pieces.length - 1], text)) {
+        pieces.push(' ');
+      }
+      pieces.push(text);
+    }
+    return pieces.join('');
+  }
+
+  #countTopLevelValuesInStringPiece(piece: string): number {
+    let count = this.#topLevelValueCounts.get(piece);
+    if (count === undefined) {
+      count = ASTUtils.siblings(ASTUtils.declValue(tokenizeDeclaration('--p', piece)?.tree ?? null)).length;
+      this.#topLevelValueCounts.set(piece, count);
+    }
+    return count;
+  }
+
+  countTopLevelValues(begin: number, end: number): number {
+    const pieces = Array.from(this.#getPieces(begin, end));
+    const counts = pieces.map(
+        chunk =>
+            (chunk instanceof ComputedTextChunk ? chunk.topLevelValueCount :
+                                                  this.#countTopLevelValuesInStringPiece(chunk)));
+    const count = counts.reduce((sum, v) => sum + v, 0);
+    return count;
+  }
+}
+
+/**
+ * This function determines whether concatenating two pieces of text requires any spacing in between. For example, there
+ * shouldn't be any space between 'var' and '(', but there should be a space between '1px' and 'solid'. The node
+ * sequences that make up the pieces of text may contain non-text nodes/trees. Any such element in between the texts is
+ * ignored for the spacing requirement.
+ **/
+export function requiresSpace(a: string, b: string): boolean;
+export function requiresSpace(a: Node[], b: Node[]): boolean;
+export function requiresSpace(a: Node[]|string|undefined, b: Node[]|string|undefined): boolean {
+  const tail = Array.isArray(a) ? a.findLast(node => node.textContent)?.textContent : a;
+  const head = Array.isArray(b) ? b.find(node => node.textContent)?.textContent : b;
+  const trailingChar = tail ? tail[tail.length - 1] : '';
+  const leadingChar = head ? head[0] : '';
+
+  const noSpaceAfter = ['', '(', '{', '}', ';', '['];
+  const noSpaceBefore = ['', '(', ')', ',', ':', '*', '{', ';', ']'];
+  return !/\s/.test(trailingChar) && !/\s/.test(leadingChar) && !noSpaceAfter.includes(trailingChar) &&
+      !noSpaceBefore.includes(leadingChar);
+}
+
+export const CSSControlMap = Map<string, HTMLElement[]>;
+export type CSSControlMap = Map<string, HTMLElement[]>;
+export namespace ASTUtils {
+  export function siblings(node: CodeMirror.SyntaxNode|null): CodeMirror.SyntaxNode[] {
+    const result = [];
+    while (node) {
+      result.push(node);
+      node = node.nextSibling;
+    }
+    return result;
+  }
+
+  export function children(node: CodeMirror.SyntaxNode|null): CodeMirror.SyntaxNode[] {
+    return siblings(node?.firstChild ?? null);
+  }
+
+  export function range(node: CodeMirror.SyntaxNode[]):
+      [CodeMirror.SyntaxNode|undefined, CodeMirror.SyntaxNode|undefined] {
+    return [node[0], node[node.length - 1]];
+  }
+
+  export function declValue(node: CodeMirror.SyntaxNode|null): CodeMirror.SyntaxNode|null {
+    if (node?.name !== 'Declaration') {
+      return null;
+    }
+    return children(node).find(node => node.name === ':')?.nextSibling ?? null;
+  }
+
+  export function* stripComments(nodes: CodeMirror.SyntaxNode[]): Generator<CodeMirror.SyntaxNode> {
+    for (const node of nodes) {
+      if (node.type.name !== 'Comment') {
+        yield node;
+      }
+    }
+  }
+
+  export function split(nodes: CodeMirror.SyntaxNode[]): CodeMirror.SyntaxNode[][] {
+    const result = [];
+    let current = [];
+    for (const node of nodes) {
+      if (node.name === ',') {
+        result.push(current);
+        current = [];
+      } else {
+        current.push(node);
+      }
+    }
+    if (nodes.length > 0) {
+      result.push(current);
+    }
+    return result;
+  }
+
+  export function callArgs(node: CodeMirror.SyntaxNode|null): CodeMirror.SyntaxNode[][] {
+    const args = children(node?.getChild('ArgList') ?? null);
+    const openParen = args.splice(0, 1)[0];
+    const closingParen = args.pop();
+
+    if (openParen?.name !== '(' || closingParen?.name !== ')') {
+      return [];
+    }
+
+    return split(args);
+  }
+
+  export function equals(a: CodeMirror.SyntaxNode, b: CodeMirror.SyntaxNode): boolean {
+    return a.name === b.name && a.from === b.from && a.to === b.to;
+  }
+}
+
+function declaration(rule: string): CodeMirror.SyntaxNode|null {
+  const cssParser = CodeMirror.css.cssLanguage.parser;
+  return cssParser.parse(rule).topNode.getChild('RuleSet')?.getChild('Block')?.getChild('Declaration') ?? null;
+}
+
+export function tokenizeDeclaration(propertyName: string, propertyValue: string): SyntaxTree|null {
+  const name = tokenizePropertyName(propertyName);
+  if (!name) {
+    return null;
+  }
+  const rule = `*{${name}: ${propertyValue};}`;
+  const decl = declaration(rule);
+  if (!decl || decl.type.isError) {
+    return null;
+  }
+
+  const childNodes = ASTUtils.children(decl);
+  if (childNodes.length < 2) {
+    return null;
+  }
+  const [varName, colon, tree] = childNodes;
+  if (!varName || varName.type.isError || !colon || colon.type.isError || tree?.type.isError) {
+    return null;
+  }
+
+  // It's possible that there are nodes following the declaration when there are comments or syntax errors. We want to
+  // render any comments, so pick up any trailing nodes following the declaration excluding the final semicolon and
+  // brace.
+  const trailingNodes = ASTUtils.siblings(decl).slice(1);
+  const [semicolon, brace] = trailingNodes.splice(trailingNodes.length - 2, 2);
+  if (semicolon?.name !== ';' && brace?.name !== '}') {
+    return null;
+  }
+
+  const ast = new SyntaxTree(propertyValue, rule, decl, name, trailingNodes);
+  if (ast.text(varName) !== name || colon.name !== ':') {
+    return null;
+  }
+  return ast;
+}
+
+export function tokenizePropertyName(name: string): string|null {
+  const rule = `*{${name}: inherit;}`;
+  const decl = declaration(rule);
+  if (!decl || decl.type.isError) {
+    return null;
+  }
+
+  const propertyName = decl.getChild('PropertyName') ?? decl.getChild('VariableName');
+  if (!propertyName) {
+    return null;
+  }
+
+  return nodeText(propertyName, rule);
+}
+
+export function matchDeclaration(name: string, value: string, matchers: Array<Matcher<Match>>): BottomUpTreeMatching|
+    null {
+  const ast = tokenizeDeclaration(name, value);
+  const matchedResult = ast && BottomUpTreeMatching.walk(ast, matchers);
+  ast?.trailingNodes.forEach(n => matchedResult?.matchText(n));
+  return matchedResult;
+}
+
+export class TreeSearch extends TreeWalker {
+  #found: CodeMirror.SyntaxNode|null = null;
+  #predicate: (node: CodeMirror.SyntaxNode) => boolean;
+
+  constructor(ast: SyntaxTree, predicate: (node: CodeMirror.SyntaxNode) => boolean) {
+    super(ast);
+    this.#predicate = predicate;
+  }
+
+  protected override enter({node}: SyntaxNodeRef): boolean {
+    if (this.#found) {
+      return false;
+    }
+
+    if (this.#predicate(node)) {
+      this.#found = this.#found ?? node;
+      return false;
+    }
+    return true;
+  }
+
+  static find(ast: SyntaxTree, predicate: (node: CodeMirror.SyntaxNode) => boolean): CodeMirror.SyntaxNode|null {
+    return TreeSearch.walk(ast, predicate).#found;
+  }
+
+  static findAll(ast: SyntaxTree, predicate: (node: CodeMirror.SyntaxNode) => boolean): CodeMirror.SyntaxNode[] {
+    const foundNodes: CodeMirror.SyntaxNode[] = [];
+    TreeSearch.walk(ast, (node: CodeMirror.SyntaxNode) => {
+      if (predicate(node)) {
+        foundNodes.push(node);
+      }
+
+      return false;
+    });
+    return foundNodes;
+  }
+}