Improve debugging message (issue 26008)

pkg/analyzer/lib/src/generated/resolver.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.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 18 matching lines @@
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
 import 'package:analyzer/src/generated/type_system.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/task/strong/info.dart'
     show InferredType, StaticInfo;
 
 export 'package:analyzer/src/generated/type_system.dart';
 
 /**
- * Throw an [ElementMismatchException] to report that the element model and the
- * AST do not match. The [message] will have the path to the given [node]
- * appended to it.
- */
-void _mismatch(String message, AstNode node) {
-  StringBuffer buffer = new StringBuffer();
-  buffer.writeln(message);
-  buffer.write('Path to root:');
-  String separator = ' ';
-  AstNode parent = node;
-  while (parent != null) {
-    buffer.write(separator);
-    buffer.write(parent.runtimeType.toString());
-    separator = ', ';
-    parent = parent.parent;
-  }
-  throw new ElementMismatchException(buffer.toString());
-}
-
-/**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
  */
 class BestPracticesVerifier extends RecursiveAstVisitor<Object> {
 //  static String _HASHCODE_GETTER_NAME = "hashCode";
 
   static String _NULL_TYPE_NAME = "Null";
 
   static String _TO_INT_METHOD_NAME = "toInt";
 
@@ skipping 2097 matching lines @@
 
 /**
  * A visitor that resolves declarations in an AST structure to already built
  * elements.
  *
  * The resulting AST must have everything resolved that would have been resolved
  * by a [CompilationUnitBuilder] (that is, must be a valid [RESOLVED_UNIT1]).
  * This class must not assume that the [CompilationUnitElement] passed to it is
  * any more complete than a [COMPILATION_UNIT_ELEMENT].
  */
-class DeclarationResolver extends RecursiveAstVisitor<Object> {
+class DeclarationResolver extends RecursiveAstVisitor<Object>
+    with ExistingElementResolver {
   /**
    * The analysis context containing the sources to be analyzed.
    */
   AnalysisContext _context;
 
   /**
    * The elements that are reachable from the compilation unit element. When a
    * compilation unit has been resolved, this set should be empty.
    */
   Set<Element> _expectedElements;
 
   /**
-   * The compilation unit containing the AST nodes being visited.
-   */
-  CompilationUnitElementImpl _enclosingUnit;
-
-  /**
    * The function type alias containing the AST nodes being visited, or `null`
    * if we are not in the scope of a function type alias.
    */
   FunctionTypeAliasElement _enclosingAlias;
 
   /**
    * The class containing the AST nodes being visited, or `null` if we are not
    * in the scope of a class.
    */
   ClassElement _enclosingClass;
@@ skipping 611 matching lines @@
   }
 }
 
 /**
  * A visitor that resolves directives in an AST structure to already built
  * elements.
  *
  * The resulting AST must have everything resolved that would have been resolved
  * by a [DirectiveElementBuilder].
  */
-class DirectiveResolver extends SimpleAstVisitor {
-  CompilationUnitElementImpl _enclosingUnit;
-
+class DirectiveResolver extends SimpleAstVisitor with ExistingElementResolver {
   @override
   void visitCompilationUnit(CompilationUnit node) {
     _enclosingUnit = node.element;
     for (Directive directive in node.directives) {
       directive.accept(this);
     }
   }
 
   @override
   void visitExportDirective(ExportDirective node) {
@@ skipping 638 matching lines @@
         new PropertyAccessorElementImpl.forVariable(field);
     getter.getter = true;
     getter.returnType = field.type;
     getter.type = new FunctionTypeImpl(getter);
     field.getter = getter;
     return getter;
   }
 }
 
 /**
+ * A mixin for classes that use an existing element model to resolve a portion
+ * of an AST structure.
+ */
+class ExistingElementResolver {
+  /**
+   * The compilation unit containing the AST nodes being visited.
+   */
+  CompilationUnitElementImpl _enclosingUnit;
+
+  /**
+   * Throw an [ElementMismatchException] to report that the element model and the
+   * AST do not match. The [message] will have the path to the given [node]
+   * appended to it.
+   */
+  void _mismatch(String message, AstNode node) {
+    StringBuffer buffer = new StringBuffer();
+    buffer.write('Mismatch in ');
+    buffer.write(runtimeType);
+    buffer.write(' while resolving ');
+    buffer.writeln(_enclosingUnit?.source?.fullName);
+    buffer.writeln(message);
+    buffer.write('Path to root:');
+    String separator = ' ';
+    AstNode parent = node;
+    while (parent != null) {
+      buffer.write(separator);
+      buffer.write(parent.runtimeType.toString());
+      separator = ', ';
+      parent = parent.parent;
+    }
+    throw new ElementMismatchException(buffer.toString());
+  }
+}
+
+/**
  * Instances of the class `ExitDetector` determine whether the visited AST node is guaranteed
  * to terminate by executing a `return` statement, `throw` expression, `rethrow`
  * expression, or simple infinite loop such as `while(true)`.
  */
 class ExitDetector extends GeneralizingAstVisitor<bool> {
   /**
    * Set to `true` when a `break` is encountered, and reset to `false` when a
    * `do`, `while`, `for` or `switch` block is entered.
    */
   bool _enclosingBlockContainsBreak = false;
@@ skipping 9455 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }