Add visitors that throw by default

pkg/analyzer/lib/dart/ast/visitor.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Defines AST visitors that support useful patterns for visiting the nodes in
  * an [AST structure](ast.dart).
  *
  * Dart is an evolving language, and the AST structure must evolved with it.
  * When the AST structure changes, the visitor interface will sometimes change
@@ skipping 32 matching lines @@
  * children (either directly or indirectly). Failure to do will break the order
  * in which nodes are visited.
  *
  * Note that, unlike other visitors that begin to visit a structure of nodes by
  * asking the root node in the structure to accept the visitor, this visitor
  * requires that clients start the visit by invoking the method [visitAllNodes]
  * defined on the visitor with the root node as the argument:
  *
  *     visitor.visitAllNodes(rootNode);
  *
- * Clients may extend or implement this class.
+ * Clients may extend this class.
  */
 class BreadthFirstVisitor<R> extends GeneralizingAstVisitor<R> {
   /**
    * A queue holding the nodes that have not yet been visited in the order in
    * which they ought to be visited.
    */
   Queue<AstNode> _queue = new Queue<AstNode>();
 
   /**
    * A visitor, used to visit the children of the current node, that will add
@@ skipping 76 matching lines @@
  * to be invoked but will also cause the methods [visitStatement] and
  * [visitNode] to be subsequently invoked. This allows visitors to be written
  * that visit all statements without needing to override the visit method for
  * each of the specific subclasses of [Statement].
  *
  * Subclasses that override a visit method must either invoke the overridden
  * visit method or explicitly invoke the more general visit method. Failure to
  * do so will cause the visit methods for superclasses of the node to not be
  * invoked and will cause the children of the visited node to not be visited.
  *
- * Clients may extend or implement this class.
+ * Clients may extend this class.
  */
 class GeneralizingAstVisitor<R> implements AstVisitor<R> {
   @override
   R visitAdjacentStrings(AdjacentStrings node) => visitStringLiteral(node);
 
   R visitAnnotatedNode(AnnotatedNode node) => visitNode(node);
 
   @override
   R visitAnnotation(Annotation node) => visitNode(node);
 
@@ skipping 408 matching lines @@
 /**
  * An AST visitor that will recursively visit all of the nodes in an AST
  * structure. For example, using an instance of this class to visit a [Block]
  * will also cause all of the statements in the block to be visited.
  *
  * Subclasses that override a visit method must either invoke the overridden
  * visit method or must explicitly ask the visited node to visit its children.
  * Failure to do so will cause the children of the visited node to not be
  * visited.
  *
- * Clients may extend or implement this class.
+ * Clients may extend this class.
  */
 class RecursiveAstVisitor<R> implements AstVisitor<R> {
   @override
   R visitAdjacentStrings(AdjacentStrings node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
   R visitAnnotation(Annotation node) {
@@ skipping 644 matching lines @@
     return null;
   }
 }
 
 /**
  * An AST visitor that will do nothing when visiting an AST node. It is intended
  * to be a superclass for classes that use the visitor pattern primarily as a
  * dispatch mechanism (and hence don't need to recursively visit a whole
  * structure) and that only need to visit a small number of node types.
  *
- * Clients may extend or implement this class.
+ * Clients may extend this class.
  */
 class SimpleAstVisitor<R> implements AstVisitor<R> {
   @override
   R visitAdjacentStrings(AdjacentStrings node) => null;
 
   @override
   R visitAnnotation(Annotation node) => null;
 
   @override
   R visitArgumentList(ArgumentList node) => null;
@@ skipping 317 matching lines @@
   R visitWhileStatement(WhileStatement node) => null;
 
   @override
   R visitWithClause(WithClause node) => null;
 
   @override
   R visitYieldStatement(YieldStatement node) => null;
 }
 
 /**
- * An AST Visitor that captures visit call timings.
+ * An AST visitor that will throw an exception if any of the visit methods that
+ * are invoked have not been overridden. It is intended to be a superclass for
+ * classes that implement the visitor pattern and need to override all of the
+ * visit methods.

[Paul Berry, 2017/01/09 17:36:51]

It would also be useful for classes that implement the visitor pattern and don't
need to override all of the visit methods, because by design they don't visit
all kinds of nodes (e.g. a visitor that traverses declarations but doesn't
recurse into method bodies).

A similar comment applies to ThrowingElementVisitor.

[Brian Wilkerson, 2017/01/09 18:08:07]

Updated comment.

+ *
+ * Clients may extend this class.
+ */
+class ThrowingAstVisitor<R> implements AstVisitor<R> {
+  @override
+  R visitAdjacentStrings(AdjacentStrings node) => _throw(node);
+
+  @override
+  R visitAnnotation(Annotation node) => _throw(node);
+
+  @override
+  R visitArgumentList(ArgumentList node) => _throw(node);
+
+  @override
+  R visitAsExpression(AsExpression node) => _throw(node);
+
+  @override
+  R visitAssertInitializer(AssertInitializer node) => _throw(node);
+
+  @override
+  R visitAssertStatement(AssertStatement node) => _throw(node);
+
+  @override
+  R visitAssignmentExpression(AssignmentExpression node) => _throw(node);
+
+  @override
+  R visitAwaitExpression(AwaitExpression node) => _throw(node);
+
+  @override
+  R visitBinaryExpression(BinaryExpression node) => _throw(node);
+
+  @override
+  R visitBlock(Block node) => _throw(node);
+
+  @override
+  R visitBlockFunctionBody(BlockFunctionBody node) => _throw(node);
+
+  @override
+  R visitBooleanLiteral(BooleanLiteral node) => _throw(node);
+
+  @override
+  R visitBreakStatement(BreakStatement node) => _throw(node);
+
+  @override
+  R visitCascadeExpression(CascadeExpression node) => _throw(node);
+
+  @override
+  R visitCatchClause(CatchClause node) => _throw(node);
+
+  @override
+  R visitClassDeclaration(ClassDeclaration node) => _throw(node);
+
+  @override
+  R visitClassTypeAlias(ClassTypeAlias node) => _throw(node);
+
+  @override
+  R visitComment(Comment node) => _throw(node);
+
+  @override
+  R visitCommentReference(CommentReference node) => _throw(node);
+
+  @override
+  R visitCompilationUnit(CompilationUnit node) => _throw(node);
+
+  @override
+  R visitConditionalExpression(ConditionalExpression node) => _throw(node);
+
+  @override
+  R visitConfiguration(Configuration node) => _throw(node);
+
+  @override
+  R visitConstructorDeclaration(ConstructorDeclaration node) => _throw(node);
+
+  @override
+  R visitConstructorFieldInitializer(ConstructorFieldInitializer node) =>
+      _throw(node);
+
+  @override
+  R visitConstructorName(ConstructorName node) => _throw(node);
+
+  @override
+  R visitContinueStatement(ContinueStatement node) => _throw(node);
+
+  @override
+  R visitDeclaredIdentifier(DeclaredIdentifier node) => _throw(node);
+
+  @override
+  R visitDefaultFormalParameter(DefaultFormalParameter node) => _throw(node);
+
+  @override
+  R visitDoStatement(DoStatement node) => _throw(node);
+
+  @override
+  R visitDottedName(DottedName node) => _throw(node);
+
+  @override
+  R visitDoubleLiteral(DoubleLiteral node) => _throw(node);
+
+  @override
+  R visitEmptyFunctionBody(EmptyFunctionBody node) => _throw(node);
+
+  @override
+  R visitEmptyStatement(EmptyStatement node) => _throw(node);
+
+  @override
+  R visitEnumConstantDeclaration(EnumConstantDeclaration node) => _throw(node);
+
+  @override
+  R visitEnumDeclaration(EnumDeclaration node) => _throw(node);
+
+  @override
+  R visitExportDirective(ExportDirective node) => _throw(node);
+
+  @override
+  R visitExpressionFunctionBody(ExpressionFunctionBody node) => _throw(node);
+
+  @override
+  R visitExpressionStatement(ExpressionStatement node) => _throw(node);
+
+  @override
+  R visitExtendsClause(ExtendsClause node) => _throw(node);
+
+  @override
+  R visitFieldDeclaration(FieldDeclaration node) => _throw(node);
+
+  @override
+  R visitFieldFormalParameter(FieldFormalParameter node) => _throw(node);
+
+  @override
+  R visitForEachStatement(ForEachStatement node) => _throw(node);
+
+  @override
+  R visitFormalParameterList(FormalParameterList node) => _throw(node);
+
+  @override
+  R visitForStatement(ForStatement node) => _throw(node);
+
+  @override
+  R visitFunctionDeclaration(FunctionDeclaration node) => _throw(node);
+
+  @override
+  R visitFunctionDeclarationStatement(FunctionDeclarationStatement node) =>
+      _throw(node);
+
+  @override
+  R visitFunctionExpression(FunctionExpression node) => _throw(node);
+
+  @override
+  R visitFunctionExpressionInvocation(FunctionExpressionInvocation node) =>
+      _throw(node);
+
+  @override
+  R visitFunctionTypeAlias(FunctionTypeAlias node) => _throw(node);
+
+  @override
+  R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) =>
+      _throw(node);
+
+  @override
+  R visitHideCombinator(HideCombinator node) => _throw(node);
+
+  @override
+  R visitIfStatement(IfStatement node) => _throw(node);
+
+  @override
+  R visitImplementsClause(ImplementsClause node) => _throw(node);
+
+  @override
+  R visitImportDirective(ImportDirective node) => _throw(node);
+
+  @override
+  R visitIndexExpression(IndexExpression node) => _throw(node);
+
+  @override
+  R visitInstanceCreationExpression(InstanceCreationExpression node) =>
+      _throw(node);
+
+  @override
+  R visitIntegerLiteral(IntegerLiteral node) => _throw(node);
+
+  @override
+  R visitInterpolationExpression(InterpolationExpression node) => _throw(node);
+
+  @override
+  R visitInterpolationString(InterpolationString node) => _throw(node);
+
+  @override
+  R visitIsExpression(IsExpression node) => _throw(node);
+
+  @override
+  R visitLabel(Label node) => _throw(node);
+
+  @override
+  R visitLabeledStatement(LabeledStatement node) => _throw(node);
+
+  @override
+  R visitLibraryDirective(LibraryDirective node) => _throw(node);
+
+  @override
+  R visitLibraryIdentifier(LibraryIdentifier node) => _throw(node);
+
+  @override
+  R visitListLiteral(ListLiteral node) => _throw(node);
+
+  @override
+  R visitMapLiteral(MapLiteral node) => _throw(node);
+
+  @override
+  R visitMapLiteralEntry(MapLiteralEntry node) => _throw(node);
+
+  @override
+  R visitMethodDeclaration(MethodDeclaration node) => _throw(node);
+
+  @override
+  R visitMethodInvocation(MethodInvocation node) => _throw(node);
+
+  @override
+  R visitNamedExpression(NamedExpression node) => _throw(node);
+
+  @override
+  R visitNativeClause(NativeClause node) => _throw(node);
+
+  @override
+  R visitNativeFunctionBody(NativeFunctionBody node) => _throw(node);
+
+  @override
+  R visitNullLiteral(NullLiteral node) => _throw(node);
+
+  @override
+  R visitParenthesizedExpression(ParenthesizedExpression node) => _throw(node);
+
+  @override
+  R visitPartDirective(PartDirective node) => _throw(node);
+
+  @override
+  R visitPartOfDirective(PartOfDirective node) => _throw(node);
+
+  @override
+  R visitPostfixExpression(PostfixExpression node) => _throw(node);
+
+  @override
+  R visitPrefixedIdentifier(PrefixedIdentifier node) => _throw(node);
+
+  @override
+  R visitPrefixExpression(PrefixExpression node) => _throw(node);
+
+  @override
+  R visitPropertyAccess(PropertyAccess node) => _throw(node);
+
+  @override
+  R visitRedirectingConstructorInvocation(
+          RedirectingConstructorInvocation node) =>
+      _throw(node);
+
+  @override
+  R visitRethrowExpression(RethrowExpression node) => _throw(node);
+
+  @override
+  R visitReturnStatement(ReturnStatement node) => _throw(node);
+
+  @override
+  R visitScriptTag(ScriptTag node) => _throw(node);
+
+  @override
+  R visitShowCombinator(ShowCombinator node) => _throw(node);
+
+  @override
+  R visitSimpleFormalParameter(SimpleFormalParameter node) => _throw(node);
+
+  @override
+  R visitSimpleIdentifier(SimpleIdentifier node) => _throw(node);
+
+  @override
+  R visitSimpleStringLiteral(SimpleStringLiteral node) => _throw(node);
+
+  @override
+  R visitStringInterpolation(StringInterpolation node) => _throw(node);
+
+  @override
+  R visitSuperConstructorInvocation(SuperConstructorInvocation node) =>
+      _throw(node);
+
+  @override
+  R visitSuperExpression(SuperExpression node) => _throw(node);
+
+  @override
+  R visitSwitchCase(SwitchCase node) => _throw(node);
+
+  @override
+  R visitSwitchDefault(SwitchDefault node) => _throw(node);
+
+  @override
+  R visitSwitchStatement(SwitchStatement node) => _throw(node);
+
+  @override
+  R visitSymbolLiteral(SymbolLiteral node) => _throw(node);
+
+  @override
+  R visitThisExpression(ThisExpression node) => _throw(node);
+
+  @override
+  R visitThrowExpression(ThrowExpression node) => _throw(node);
+
+  @override
+  R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) =>
+      _throw(node);
+
+  @override
+  R visitTryStatement(TryStatement node) => _throw(node);
+
+  @override
+  R visitTypeArgumentList(TypeArgumentList node) => _throw(node);
+
+  @override
+  R visitTypeName(TypeName node) => _throw(node);
+
+  @override
+  R visitTypeParameter(TypeParameter node) => _throw(node);
+
+  @override
+  R visitTypeParameterList(TypeParameterList node) => _throw(node);
+
+  @override
+  R visitVariableDeclaration(VariableDeclaration node) => _throw(node);
+
+  @override
+  R visitVariableDeclarationList(VariableDeclarationList node) => _throw(node);
+
+  @override
+  R visitVariableDeclarationStatement(VariableDeclarationStatement node) =>
+      _throw(node);
+
+  @override
+  R visitWhileStatement(WhileStatement node) => _throw(node);
+
+  @override
+  R visitWithClause(WithClause node) => _throw(node);
+
+  @override
+  R visitYieldStatement(YieldStatement node) => _throw(node);
+
+  R _throw(AstNode node) {
+    throw new Exception('Missing implementation of visit${node.runtimeType}');
+  }
+}
+
+/**
+ * An AST visitor that captures visit call timings.
+ *
+ * Clients may not extend, implement or mix-in this class.
  */
 class TimedAstVisitor<T> implements AstVisitor<T> {
   /**
    * The base visitor whose visit methods will be timed.
    */
   final AstVisitor<T> _baseVisitor;
 
   /**
    * Collects elapsed time for visit calls.
    */
@@ skipping 883 matching lines @@
 /**
  * An AST visitor that will recursively visit all of the nodes in an AST
  * structure (like instances of the class [RecursiveAstVisitor]). In addition,
  * every node will also be visited by using a single unified [visitNode] method.
  *
  * Subclasses that override a visit method must either invoke the overridden
  * visit method or explicitly invoke the more general [visitNode] method.
  * Failure to do so will cause the children of the visited node to not be
  * visited.
  *
- * Clients may extend or implement this class.
+ * Clients may extend this class.
  */
 class UnifyingAstVisitor<R> implements AstVisitor<R> {
   @override
   R visitAdjacentStrings(AdjacentStrings node) => visitNode(node);
 
   @override
   R visitAnnotation(Annotation node) => visitNode(node);
 
   @override
   R visitArgumentList(ArgumentList node) => visitNode(node);
@@ skipping 350 matching lines @@
    * Initialize a newly created visitor to help the [outerVisitor].
    */
   _BreadthFirstChildVisitor(this.outerVisitor);
 
   @override
   Object visitNode(AstNode node) {
     outerVisitor._queue.add(node);
     return null;
   }
 }