Visits this node, then visits the break label if non-{@code null}.
331260
@Override
    public void visit(NodeVisitor v) {
        if (v.visit(this) && breakLabel != null) {
            breakLabel.visit(v);
        }
    }
635395
function enterBreakableStatement(node) {
            scopeInfo = {
                label: node.parent.type === "LabeledStatement" ? node.parent.label : null,
                breakable: true,
                upper: scopeInfo
            };
        }
786316
private void visit(final ObjectGraphNode currentNode) {
		Object currentValue = currentNode.getValue();

		if (currentValue == null
				|| (currentValue instanceof java.lang.ref.SoftReference)
				|| currentNode.isPrimitive() || currentNode.isSimpleType()) {
			return;
		}

		if (isObjectVisited(currentNode)) {
			ObjectGraphNode ref = visitedNodes.get(currentValue);
			currentNode.setRefNode(ref);
			return;
		}

		markObjectVisited(currentNode);

		if (currentValue instanceof List) {
			// ArrayList's elementData is marked transient, and others may be as well, so we have to do this ourselves.
			visitList(currentNode);
		} else if (currentValue instanceof Map) {
			// HashMap's table is marked transient, and others may be as well, so we have to do this ourselves.
			visitMap(currentNode);
		} else if (currentValue instanceof ComponentModel) {
			// Special case for ComponentModel, so we can figure out if any fields are overridden
			visitComponentModel(currentNode);
		} else if (currentValue instanceof Field) {
			visitComplexType(currentNode);
			summariseNode(currentNode);
		} else if (currentValue.getClass().isArray()) {
			visitArray(currentNode);
		} else {
			visitComplexType(currentNode);
		}
	}
950457
def visit_if(self, node, parent):
        """"""
        newnode = nodes.If(node.lineno, node.col_offset, parent)
        newnode.postinit(
            self.visit(node.test, newnode),
            [self.visit(child, newnode) for child in node.body],
            [self.visit(child, newnode) for child in node.orelse],
        )
        return newnode
530629
void tryMinimizeSwitchCaseExits(Node n, Token exitType, @Nullable String labelName) {
    checkState(NodeUtil.isSwitchCase(n));

    checkState(n != n.getParent().getLastChild());
    Node block = n.getLastChild();
    Node maybeBreak = block.getLastChild();
    if (maybeBreak == null || !maybeBreak.isBreak() || maybeBreak.hasChildren()) {
      // Can not minimize exits from a case without an explicit break from the switch.
      return;
    }

    // Now try to minimize the exits of the last child before the break, if it is removed
    // look at what has become the child before the break.
    Node childBeforeBreak = maybeBreak.getPrevious();
    while (childBeforeBreak != null) {
      Node c = childBeforeBreak;
      tryMinimizeExits(c, exitType, labelName);
      // If the node is still the last child, we are done.
      childBeforeBreak = maybeBreak.getPrevious();
      if (c == childBeforeBreak) {
        break;
      }
    }
  }
1063065
public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }
1108338
function visit(ast, callback) {
            if(callback && typeof callback.visitNode === 'function') {
            	var ret = visitNode(callback, ast);
                endVisitNode(callback, ast);
                if(ret === this.BREAK) {
                    return;
                }
            }
        }
1162669
private static <I> void markAndPropagate(DTNode<I> node, Boolean label) {
        DTNode<I> curr = node;

        while (curr != null && curr.getSplitData() != null) {
            if (!curr.getSplitData().mark(label)) {
                return;
            }
            curr = curr.getParent();
        }
    }
1189911
public void mark(Label label) {
        adopt(label);
        if (label.marked) {
            throw new IllegalStateException("already marked");
        }
        label.marked = true;
        if (currentLabel != null) {
            jump(label); // blocks must end with a branch, return or throw
        }
        currentLabel = label;
    }
294273
@Override
    public void visit(NodeVisitor v) {
        if (v.visit(this)) {
            target.visit(v);
            element.visit(v);
        }
    }
148159
@Override
    public void visit(NodeVisitor v) {
        if (v.visit(this)) {
            for (ObjectProperty prop : getElements()) {
                prop.visit(v);
            }
        }
    }
378113
final public void Choice() throws ParseException {
    Or();
    label_6:
    while (true) {
      if (jj_2_5(3)) {
        ;
      } else {
        break label_6;
      }
      jj_consume_token(QUESTIONMARK);
      Choice();
      jj_consume_token(COLON);
                                                         AstChoice jjtn001 = new AstChoice(JJTCHOICE);
                                                         boolean jjtc001 = true;
                                                         jjtree.openNodeScope(jjtn001);
      try {
        Choice();
      } catch (Throwable jjte001) {
                                                         if (jjtc001) {
                                                           jjtree.clearNodeScope(jjtn001);
                                                           jjtc001 = false;
                                                         } else {
                                                           jjtree.popNode();
                                                         }
                                                         if (jjte001 instanceof RuntimeException) {
                                                           {if (true) throw (RuntimeException)jjte001;}
                                                         }
                                                         if (jjte001 instanceof ParseException) {
                                                           {if (true) throw (ParseException)jjte001;}
                                                         }
                                                         {if (true) throw (Error)jjte001;}
      } finally {
                                                         if (jjtc001) {
                                                           jjtree.closeNodeScope(jjtn001,  3);
                                                         }
      }
    }
  }
674961
protected void visitChildNodes(NodeData node) throws RepositoryException
   {
      if (isInterrupted())
         return;
      for (NodeData data : dataManager.getChildNodesData(node))
      {
         if (isInterrupted())
            return;
         data.accept(this);
      }
   }
501361
public final R visit(DocTree node, P p) {
        return (node == null) ? null : node.accept(this, p);
    }
1192530
@Override
  public void visit(NodeTraversal t, Node n, Node parent) {
    if (n.isName() || n.isImportStar() || (n.isStringKey() && !n.hasChildren())) {
      if ((parent.isImportSpec() && n != parent.getLastChild())
          || (parent.isExportSpec() && n != parent.getFirstChild())) {
        // The n in `import {n as x}` or `export {x as n}` are not references, even though
        // they are represented in the AST as NAME nodes.
        return;
      }

      Var v = t.getScope().getVar(n.getString());

      if (v != null) {
        if (varFilter.apply(v)) {
          addReference(v, new Reference(n, t, peek(blockStack)));
        }

        if (v.getParentNode() != null
            && NodeUtil.isHoistedFunctionDeclaration(v.getParentNode())
            // If we're only traversing a narrow scope, do not try to climb outside.
            && (narrowScope == null || narrowScope.getDepth() <= v.getScope().getDepth())) {
          outOfBandTraversal(v);
        }
      }
    }

    if (isBlockBoundary(n, parent)) {
      pop(blockStack);
    }
  }
854081
@Override
    public Object visit(ParseTree tree) {
        if (!asBoolean(tree)) {
            return null;
        }

        return super.visit(tree);
    }
5527
@Override
    public void visit(NodeVisitor v) {
        if (v.visit(this)) {
            testExpression.visit(v);
            trueExpression.visit(v);
            falseExpression.visit(v);
        }
    }