Check that all elements are associated with nodes when resolving using an existing element model

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/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/utilities.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/error_verifier.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
@@ skipping 2000 matching lines @@
     }
   }
 }
 
 /**
  * A visitor that resolves declarations in an AST structure to already built
  * elements.
  */
 class DeclarationResolver extends RecursiveAstVisitor<Object> {
   /**
+   * 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.
    */
   CompilationUnitElement _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;
 
@@ skipping 14 matching lines @@
    * not in the scope of a parameter.
    */
   ParameterElement _enclosingParameter;
 
   /**
    * Resolve the declarations within the given compilation [unit] to the
    * elements rooted at the given [element]. Throw an [ElementMismatchException]
    * if the element model and compilation unit do not match each other.
    */
   void resolve(CompilationUnit unit, CompilationUnitElement element) {
+    ElementGatherer gatherer = new ElementGatherer();
+    element.accept(gatherer);
+    _expectedElements = gatherer.elements;
     _enclosingUnit = element;
+    _expectedElements.remove(element);
     unit.element = element;
     unit.accept(this);
+    _validateResolution();
   }
 
   @override
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       List<LocalVariableElement> localVariables =
           _enclosingExecutable.localVariables;
       _findIdentifier(localVariables, exceptionParameter);
       SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
@@ skipping 45 matching lines @@
       } else {
         _enclosingExecutable =
             _enclosingClass.getNamedConstructor(constructorName.name);
         if (_enclosingExecutable == null) {
           _mismatch(
               'Could not find constructor element with name "${constructorName.name}',
               node);
         }
         constructorName.staticElement = _enclosingExecutable;
       }
+      _expectedElements.remove(_enclosingExecutable);
       node.element = _enclosingExecutable as ConstructorElement;
       super.visitConstructorDeclaration(node);
       _resolveMetadata(node.metadata, _enclosingExecutable);
       return null;
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
@@ skipping 112 matching lines @@
             accessors = _enclosingClass.accessors;
           } else {
             accessors = _enclosingUnit.accessors;
           }
           PropertyAccessorElement accessor;
           if ((property as KeywordToken).keyword == Keyword.GET) {
             accessor = _findIdentifier(accessors, functionName);
           } else if ((property as KeywordToken).keyword == Keyword.SET) {
             accessor = _findWithNameAndOffset(accessors, functionName,
                 functionName.name + '=', functionName.offset);
+            _expectedElements.remove(accessor);
             functionName.staticElement = accessor;
           }
           _enclosingExecutable = accessor;
         }
       }
       node.functionExpression.element = _enclosingExecutable;
       super.visitFunctionDeclaration(node);
       _resolveMetadata(node.metadata, _enclosingExecutable);
       return null;
     } finally {
@@ skipping 90 matching lines @@
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (property == null) {
         _enclosingExecutable = _findWithNameAndOffset(_enclosingClass.methods,
             methodName, nameOfMethod, methodName.offset);
+        _expectedElements.remove(_enclosingExecutable);
         methodName.staticElement = _enclosingExecutable;
       } else {
         PropertyAccessorElement accessor;
         if ((property as KeywordToken).keyword == Keyword.GET) {
           accessor = _findIdentifier(_enclosingClass.accessors, methodName);
         } else if ((property as KeywordToken).keyword == Keyword.SET) {
           accessor = _findWithNameAndOffset(_enclosingClass.accessors,
               methodName, methodName.name + '=', methodName.offset);
+          _expectedElements.remove(accessor);
           methodName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
       super.visitMethodDeclaration(node);
       _resolveMetadata(node.metadata, _enclosingExecutable);
       return null;
     } finally {
       _enclosingExecutable = outerExecutable;
     }
@@ skipping 157 matching lines @@
    * declaration with the given [identifier]. As a side-effect, associate the
    * returned element with the identifier. Throw an [ElementMismatchException]
    * if an element corresponding to the identifier cannot be found unless
    * [required] is `false`, in which case return `null`.
    */
   Element _findIdentifier(List<Element> elements, SimpleIdentifier identifier,
       {bool required: true}) {
     Element element = _findWithNameAndOffset(
         elements, identifier, identifier.name, identifier.offset,
         required: required);
+    _expectedElements.remove(element);
     identifier.staticElement = element;
     return element;
   }
 
   /**
    * Return the import element from the given list of [imports] whose library
    * has the given [source] and that has the given [prefix]. Throw an
    * [ElementMismatchException] if an element corresponding to the identifier
    * cannot be found.
    */
@@ skipping 154 matching lines @@
    */
   void _resolveMetadata(NodeList<Annotation> astMetadata, Element element) {
     if (element != null) {
       List<ElementAnnotation> elementMetadata = element.metadata;
       assert(astMetadata.length == elementMetadata.length);
       for (int i = 0; i < astMetadata.length; i++) {
         astMetadata[i].elementAnnotation = elementMetadata[i];
       }
     }
   }
+
+  /**
+   * Throw an exception if there are non-synthetic elements in the element model
+   * that were not associated with an AST node.
+   */
+  void _validateResolution() {
+    if (_expectedElements.isNotEmpty) {
+      StringBuffer buffer = new StringBuffer();
+      buffer.write(_expectedElements.length);
+      buffer.writeln(' unmatched elements found:');
+      for (Element element in _expectedElements) {
+        buffer.write('  ');
+        buffer.writeln(element);
+      }
+      throw new ElementMismatchException(buffer.toString());
+    }
+  }
 }
 
 /**
  * Instances of the class `ElementHolder` hold on to elements created while traversing an AST
  * structure so that they can be accessed when creating their enclosing element.
  */
 class ElementHolder {
   List<PropertyAccessorElement> _accessors;
 
   List<ConstructorElement> _constructors;
@@ skipping 9895 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }