Guard against exceptions thrown by linters (issue 27545)

pkg/analyzer/lib/src/dart/ast/utilities.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.
 
 library analyzer.src.dart.ast.utilities;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisEngine;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart' show TokenMap;
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
+ * A function used to handle exceptions that are thrown by delegates while using
+ * an [ExceptionHandlingDelegatingAstVisitor].
+ */
+typedef void ExceptionInDelagateHandler(

[scheglov, 2016/10/07 21:16:44]

Delegate

+    AstNode node, AstVisitor visitor, dynamic exception, StackTrace stackTrace);
+
+/**
  * An AST visitor that will clone any AST structure that it visits. The cloner
  * will only clone the structure, it will not preserve any resolution results or
  * properties associated with the nodes.
  */
 class AstCloner implements AstVisitor<AstNode> {
   /**
    * A flag indicating whether tokens should be cloned while cloning an AST
    * structure.
    */
   final bool cloneTokens;
@@ skipping 2592 matching lines @@
       return parent.uriElement;
     }
     return null;
   }
 
   @override
   Element visitVariableDeclaration(VariableDeclaration node) => node.element;
 }
 
 /**
+ * A [DelegatingAstVisitor] that will additionally catch all exceptions from the
+ * delegates without stopping the visiting. A function must be provided that
+ * will be invoked for each such exception.
+ *
+ * Clients may not extend, implement or mix-in this class.
+ */
+class ExceptionHandlingDelegatingAstVisitor<T> extends DelegatingAstVisitor<T> {
+  /**
+   * The function that will be executed for each exception that is thrown by one
+   * of the visit methods on the delegate.
+   */
+  final ExceptionInDelagateHandler handler;
+
+  /**
+   * Initialize a newly created visitor to use each of the given delegate
+   * visitors to visit the nodes of an AST structure.
+   */
+  ExceptionHandlingDelegatingAstVisitor(
+      Iterable<AstVisitor<T>> delegates, this.handler)
+      : super(delegates) {
+    if (handler == null) {
+      throw new ArgumentError('A handler must be provided');
+    }
+  }
+
+  @override
+  T visitNode(AstNode node) {
+    delegates.forEach((delegate) {
+      try {
+        node.accept(delegate);
+      } catch (exception, stackTrace) {
+        handler(node, delegate, exception, stackTrace);
+      }
+    });
+    node.visitChildren(this);
+    return null;
+  }
+
+  /**
+   * A function that can be used with instances of this class to log and then
+   * ignore any exceptions that are thrown by any of the delegates.
+   */
+  static void logException(AstNode node, AstVisitor visitor, dynamic exception,
+      StackTrace stackTrace) {
+    StringBuffer buffer = new StringBuffer();
+    buffer.write('Exception while using a ${visitor.runtimeType} to visit a ');
+    AstNode currentNode = node;
+    bool first = true;
+    while (currentNode != null) {
+      if (first) {
+        first = false;
+      } else {
+        buffer.write('in ');
+      }
+      buffer.write(currentNode.runtimeType);
+      currentNode = currentNode.parent;
+    }
+    AnalysisEngine.instance.logger.logError(
+        buffer.toString(), new CaughtException(exception, stackTrace));
+  }
+}
+
+/**
  * An object that will clone any AST structure that it visits. The cloner will
  * clone the structure, replacing the specified ASTNode with a new ASTNode,
  * mapping the old token stream to a new token stream, and preserving resolution
  * results.
  */
 @deprecated
 class IncrementalAstCloner implements AstVisitor<AstNode> {
   /**
    * The node to be replaced during the cloning process.
    */
@@ skipping 5192 matching lines @@
    * Safely visit the given [token], printing the [suffix] after the token if it
    * is non-`null`.
    */
   void _visitTokenWithSuffix(Token token, String suffix) {
     if (token != null) {
       _writer.print(token.lexeme);
       _writer.print(suffix);
     }
   }
 }