Add visitors that throw by default

pkg/analyzer/lib/dart/element/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 element visitors that support useful patterns for visiting the
  * elements in an [element model](element.dart).
  *
  * Dart is an evolving language, and the element model must evolved with it.
  * When the element model changes, the visitor interface will sometimes change
@@ skipping 64 matching lines @@
  *           LocalVariableElement
  *           ParameterElement
  *               FieldFormalParameterElement
  * </pre>
  *
  * 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 element 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 GeneralizingElementVisitor<R> implements ElementVisitor<R> {
   @override
   R visitClassElement(ClassElement element) => visitElement(element);
 
   @override
   R visitCompilationUnitElement(CompilationUnitElement element) =>
       visitElement(element);
 
   @override
@@ skipping 86 matching lines @@
  * A visitor that will recursively visit all of the element in an element model.
  * For example, using an instance of this class to visit a
  * [CompilationUnitElement] will also cause all of the types in the compilation
  * unit to be visited.
  *
  * Subclasses that override a visit method must either invoke the overridden
  * visit method or must explicitly ask the visited element to visit its
  * children. Failure to do so will cause the children of the visited element to
  * not be visited.
  *
- * Clients may extend or implement this class.
+ * Clients may extend this class.
  */
 class RecursiveElementVisitor<R> implements ElementVisitor<R> {
   @override
   R visitClassElement(ClassElement element) {
     element.visitChildren(this);
     return null;
   }
 
   @override
   R visitCompilationUnitElement(CompilationUnitElement element) {
@@ skipping 103 matching lines @@
     return null;
   }
 }
 
 /**
  * A visitor that will do nothing when visiting an element. 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 element types.
  *
- * Clients may extend or implement this class.
+ * Clients may extend this class.
  */
 class SimpleElementVisitor<R> implements ElementVisitor<R> {
   @override
   R visitClassElement(ClassElement element) => null;
 
   @override
   R visitCompilationUnitElement(CompilationUnitElement element) => null;
 
   @override
   R visitConstructorElement(ConstructorElement element) => null;
@@ skipping 40 matching lines @@
 
   @override
   R visitPropertyAccessorElement(PropertyAccessorElement element) => null;
 
   @override
   R visitTopLevelVariableElement(TopLevelVariableElement element) => null;
 
   @override
   R visitTypeParameterElement(TypeParameterElement element) => null;
 }
+
+/**
+ * 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.
+ *
+ * Clients may extend this class.
+ */
+class ThrowingElementVisitor<R> implements ElementVisitor<R> {
+  @override
+  R visitClassElement(ClassElement element) => _throw(element);
+
+  @override
+  R visitCompilationUnitElement(CompilationUnitElement element) =>
+      _throw(element);
+
+  @override
+  R visitConstructorElement(ConstructorElement element) => _throw(element);
+
+  @override
+  R visitExportElement(ExportElement element) => _throw(element);
+
+  @override
+  R visitFieldElement(FieldElement element) => _throw(element);
+
+  @override
+  R visitFieldFormalParameterElement(FieldFormalParameterElement element) =>
+      _throw(element);
+
+  @override
+  R visitFunctionElement(FunctionElement element) => _throw(element);
+
+  @override
+  R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) =>
+      _throw(element);
+
+  @override
+  R visitImportElement(ImportElement element) => _throw(element);
+
+  @override
+  R visitLabelElement(LabelElement element) => _throw(element);
+
+  @override
+  R visitLibraryElement(LibraryElement element) => _throw(element);
+
+  @override
+  R visitLocalVariableElement(LocalVariableElement element) => _throw(element);
+
+  @override
+  R visitMethodElement(MethodElement element) => _throw(element);
+
+  @override
+  R visitMultiplyDefinedElement(MultiplyDefinedElement element) =>
+      _throw(element);
+
+  @override
+  R visitParameterElement(ParameterElement element) => _throw(element);
+
+  @override
+  R visitPrefixElement(PrefixElement element) => _throw(element);
+
+  @override
+  R visitPropertyAccessorElement(PropertyAccessorElement element) =>
+      _throw(element);
+
+  @override
+  R visitTopLevelVariableElement(TopLevelVariableElement element) =>
+      _throw(element);
+
+  @override
+  R visitTypeParameterElement(TypeParameterElement element) => _throw(element);
+
+  R _throw(Element element) {
+    throw new Exception(
+        'Missing implementation of visit${element.runtimeType}');
+  }
+}