Improvements and tests for top-level variables matching.

pkg/analyzer/lib/src/generated/incremental_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 engine.incremental_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 31 matching lines @@
    * the scope of a method or function.
    */
   ExecutableElement _enclosingExecutable;
 
   /**
    * The parameter containing the AST nodes being visited, or `null` if we are not in the
    * scope of a parameter.
    */
   ParameterElement _enclosingParameter;
 
+  bool _inTopLevelVariableDeclaration = false;
+
   /**
    * A set containing all of the elements in the element model that were defined by the old AST node
    * corresponding to the AST node being visited.
    */
   HashSet<Element> _allElements = new HashSet<Element>();
 
   /**
    * A set containing all of the elements in the element model that were defined by the old AST node
    * corresponding to the AST node being visited that have not already been matched to nodes in the
    * AST structure being visited.
@@ skipping 10 matching lines @@
    *         element model
    */
   bool matches(AstNode node, Element element) {
     _captureEnclosingElements(element);
     _gatherElements(element);
     try {
       node.accept(this);
     } on _DeclarationMismatchException catch (exception) {
       return false;
     }
+    print(_unmatchedElements.join('\n'));
     return _unmatchedElements.isEmpty;
   }
 
-  void processElement(Element element) {
-    if (element == null) {
-      throw new _DeclarationMismatchException();
-    }
-    if (!_allElements.contains(element)) {
-      throw new _DeclarationMismatchException();
-    }
-    _unmatchedElements.remove(element);
-  }
-
   @override
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       List<LocalVariableElement> localVariables =
           _enclosingExecutable.localVariables;
       LocalVariableElement exceptionElement =
           _findIdentifier(localVariables, exceptionParameter);
-      processElement(exceptionElement);
+      _processElement(exceptionElement);
       SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
       if (stackTraceParameter != null) {
         LocalVariableElement stackTraceElement =
             _findIdentifier(localVariables, stackTraceParameter);
-        processElement(stackTraceElement);
+        _processElement(stackTraceElement);
       }
     }
     return super.visitCatchClause(node);
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
       _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
-      processElement(_enclosingClass);
+      _processElement(_enclosingClass);
       if (!_hasConstructor(node)) {
         ConstructorElement constructor = _enclosingClass.unnamedConstructor;
         if (constructor.isSynthetic) {
-          processElement(constructor);
+          _processElement(constructor);
         }
       }
       return super.visitClassDeclaration(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
       _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
-      processElement(_enclosingClass);
+      _processElement(_enclosingClass);
       return super.visitClassTypeAlias(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   @override
   Object visitCompilationUnit(CompilationUnit node) {
-    processElement(_enclosingUnit);
+    _processElement(_enclosingUnit);
     return super.visitCompilationUnit(node);
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier constructorName = node.name;
       if (constructorName == null) {
         _enclosingExecutable = _enclosingClass.unnamedConstructor;
       } else {
         _enclosingExecutable =
             _enclosingClass.getNamedConstructor(constructorName.name);
       }
-      processElement(_enclosingExecutable);
+      _processElement(_enclosingExecutable);
       return super.visitConstructorDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     LocalVariableElement element =
         _findIdentifier(_enclosingExecutable.localVariables, variableName);
-    processElement(element);
+    _processElement(element);
     return super.visitDeclaredIdentifier(node);
   }
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     SimpleIdentifier parameterName = node.parameter.identifier;
     ParameterElement element = _getElementForParameter(node, parameterName);
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
           // TODO(brianwilkerson) Report this internal error.
         } else {
           _enclosingExecutable = element.initializer;
         }
         defaultValue.accept(this);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
-      processElement(_enclosingExecutable);
+      _processElement(_enclosingExecutable);
     }
     ParameterElement outerParameter = _enclosingParameter;
     try {
       _enclosingParameter = element;
-      processElement(_enclosingParameter);
+      _processElement(_enclosingParameter);
       return super.visitDefaultFormalParameter(node);
     } finally {
       _enclosingParameter = outerParameter;
     }
   }
 
   @override
   Object visitEnumDeclaration(EnumDeclaration node) {
     ClassElement enclosingEnum =
         _findIdentifier(_enclosingUnit.enums, node.name);
-    processElement(enclosingEnum);
+    _processElement(enclosingEnum);
     List<FieldElement> constants = enclosingEnum.fields;
     for (EnumConstantDeclaration constant in node.constants) {
       FieldElement constantElement = _findIdentifier(constants, constant.name);
-      processElement(constantElement);
+      _processElement(constantElement);
     }
     return super.visitEnumDeclaration(node);
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
       ExportElement exportElement = _findExport(
           library.exports,
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
-      processElement(exportElement);
+      _processElement(exportElement);
     }
     return super.visitExportDirective(node);
   }
 
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
-        processElement(_enclosingParameter);
+        _processElement(_enclosingParameter);
         return super.visitFieldFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFieldFormalParameter(node);
     }
   }
 
   @override
@@ skipping 11 matching lines @@
               _findIdentifier(_enclosingUnit.functions, functionName);
         }
       } else {
         PropertyAccessorElement accessor =
             _findIdentifier(_enclosingUnit.accessors, functionName);
         if ((property as KeywordToken).keyword == Keyword.SET) {
           accessor = accessor.variable.setter;
         }
         _enclosingExecutable = accessor;
       }
-      processElement(_enclosingExecutable);
+      _processElement(_enclosingExecutable);
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
       FunctionElement element =
           _findAtOffset(_enclosingExecutable.functions, node.beginToken.offset);
-      processElement(element);
+      _processElement(element);
     }
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       _enclosingExecutable = node.element;
-      processElement(_enclosingExecutable);
+      _processElement(_enclosingExecutable);
       return super.visitFunctionExpression(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElement outerAlias = _enclosingAlias;
     try {
       SimpleIdentifier aliasName = node.name;
       _enclosingAlias =
           _findIdentifier(_enclosingUnit.functionTypeAliases, aliasName);
-      processElement(_enclosingAlias);
+      _processElement(_enclosingAlias);
       return super.visitFunctionTypeAlias(node);
     } finally {
       _enclosingAlias = outerAlias;
     }
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
-        processElement(_enclosingParameter);
+        _processElement(_enclosingParameter);
         return super.visitFunctionTypedFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFunctionTypedFormalParameter(node);
     }
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
       ImportElement importElement = _findImport(
           library.imports,
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri),
           node.prefix);
-      processElement(importElement);
+      _processElement(importElement);
     }
     return super.visitImportDirective(node);
   }
 
   @override
   Object visitLabeledStatement(LabeledStatement node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElement element =
           _findIdentifier(_enclosingExecutable.labels, labelName);
-      processElement(element);
+      _processElement(element);
     }
     return super.visitLabeledStatement(node);
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
@@ skipping 10 matching lines @@
         methodName.staticElement = _enclosingExecutable;
       } else {
         PropertyAccessorElement accessor =
             _findIdentifier(_enclosingClass.accessors, methodName);
         if ((property as KeywordToken).keyword == Keyword.SET) {
           accessor = accessor.variable.setter;
           methodName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
-      processElement(_enclosingExecutable);
+      _processElement(_enclosingExecutable);
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitPartDirective(PartDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       Source partSource =
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri);
       CompilationUnitElement element =
           _findPart(_enclosingUnit.library.parts, partSource);
-      processElement(element);
+      _processElement(element);
     }
     return super.visitPartDirective(node);
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
-        processElement(_enclosingParameter);
+        _processElement(_enclosingParameter);
         return super.visitSimpleFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
     }
     return super.visitSimpleFormalParameter(node);
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElement element =
           _findIdentifier(_enclosingExecutable.labels, labelName);
-      processElement(element);
+      _processElement(element);
     }
     return super.visitSwitchCase(node);
   }
 
   @override
   Object visitSwitchDefault(SwitchDefault node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElement element =
           _findIdentifier(_enclosingExecutable.labels, labelName);
-      processElement(element);
+      _processElement(element);
     }
     return super.visitSwitchDefault(node);
   }
 
   @override
+  Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+    _inTopLevelVariableDeclaration = true;
+    try {
+      return super.visitTopLevelVariableDeclaration(node);
+    } finally {
+      _inTopLevelVariableDeclaration = false;
+    }
+  }
+
+  @override
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     TypeParameterElement element = null;
     if (_enclosingClass != null) {
       element = _findIdentifier(_enclosingClass.typeParameters, parameterName);
     } else if (_enclosingAlias != null) {
       element = _findIdentifier(_enclosingAlias.typeParameters, parameterName);
     }
-    processElement(element);
+    _processElement(element);
     return super.visitTypeParameter(node);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
-    VariableElement element = null;
-    SimpleIdentifier variableName = node.name;
+    String name = node.name.name;
+    if (_inTopLevelVariableDeclaration) {
+      TopLevelVariableElement variable =
+          _findElement(_enclosingUnit.topLevelVariables, name);
+      _assertNotNull(variable);
+      _assertFalse(variable.isSynthetic);
+      _assertEquals(node.isConst, variable.isConst);
+      _assertEquals(node.isFinal, variable.isFinal);
+      _assertSameType(
+          (node.parent as VariableDeclarationList).type,
+          variable.type);
+      _processElement(variable);
+      return null;
+    }
+    VariableElement element;
     if (_enclosingExecutable != null) {
-      element =
-          _findIdentifier(_enclosingExecutable.localVariables, variableName);
+      element = _findElement(_enclosingExecutable.localVariables, name);
     }
     if (element == null && _enclosingClass != null) {
-      element = _findIdentifier(_enclosingClass.fields, variableName);
-    }
-    if (element == null && _enclosingUnit != null) {
-      element = _findIdentifier(_enclosingUnit.topLevelVariables, variableName);
-    }
-    Expression initializer = node.initializer;
-    if (initializer != null) {
-      ExecutableElement outerExecutable = _enclosingExecutable;
-      try {
-        if (element == null) {
-          // TODO(brianwilkerson) Report this internal error.
-        } else {
-          _enclosingExecutable = element.initializer;
-        }
-        processElement(element);
-        processElement(_enclosingExecutable);
-        return super.visitVariableDeclaration(node);
-      } finally {
-        _enclosingExecutable = outerExecutable;
-      }
+      element = _findElement(_enclosingClass.fields, name);
     }
     return super.visitVariableDeclaration(node);
   }
 
+  void _assertSameType(TypeName node, DartType type) {
+    String nodeName = node.name.name;
+    if (type is InterfaceType) {
+      _assertEquals(nodeName, type.name);
+      TypeArgumentList nodeArgumentList = node.typeArguments;
+      List<DartType> typeArguments = type.typeArguments;
+      if (nodeArgumentList == null) {
+        _assertTrue(typeArguments.isEmpty);
+      } else {
+        List<TypeName> nodeArguments = nodeArgumentList.arguments;
+        int numArguments = nodeArguments.length;
+        _assertEquals(numArguments, typeArguments.length);
+        for (int i = 0; i < numArguments; i++) {
+          _assertSameType(nodeArguments[i], typeArguments[i]);
+        }
+      }
+    } else {
+      // TODO(scheglov) support other types
+      _assertTrue(false);
+    }
+  }
+
+  void _assertFalse(bool condition) {
+    if (condition) {
+      throw new _DeclarationMismatchException();
+    }
+  }
+
+  void _assertNotNull(Element element) {
+    if (element == null) {
+      throw new _DeclarationMismatchException();
+    }
+  }
+
+  void _assertEquals(Object a, Object b) {
+    if (a != b) {
+      throw new _DeclarationMismatchException();
+    }
+  }
+
+  void _assertTrue(bool condition) {
+    if (!condition) {
+      throw new _DeclarationMismatchException();
+    }
+  }
+
   /**
    * Given that the comparison is to begin with the given element, capture the enclosing elements
    * that might be used while performing the comparison.
    *
    * @param element the element corresponding to the AST structure to be compared
    */
   void _captureEnclosingElements(Element element) {
     Element parent =
         element is CompilationUnitElement ? element : element.enclosingElement;
     while (parent != null) {
@@ skipping 25 matching lines @@
    * given offset. This method should only be used when there is no name
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param offset the offset of the name of the element to be returned
    * @return the element at the given offset
    */
   Element _findAtOffset(List<Element> elements, int offset) =>
       _findWithNameAndOffset(elements, "", offset);
 
   /**
+   * Return the [Element] in [elements] with the given [name].
+   */
+  Element _findElement(List<Element> elements, String name) {
+    for (Element element in elements) {
+      if (element.displayName == name) {
+        return element;
+      }
+    }
+    return null;
+  }
+
+  /**
    * Return the export element from the given array whose library has the given source, or
    * `null` if there is no such export.
    *
    * @param exports the export elements being searched
    * @param source the source of the library associated with the export element to being searched
    *          for
    * @return the export element whose library has the given source
    */
   ExportElement _findExport(List<ExportElement> exports, Source source) {
     for (ExportElement export in exports) {
@@ skipping 132 matching lines @@
    * @return `true` if the class defines at least one constructor
    */
   bool _hasConstructor(ClassDeclaration node) {
     for (ClassMember member in node.members) {
       if (member is ConstructorDeclaration) {
         return true;
       }
     }
     return false;
   }
+
+  void _processElement(Element element) {
+    _assertNotNull(element);
+    if (!_allElements.contains(element)) {
+      throw new _DeclarationMismatchException();
+    }
+    bool did = _unmatchedElements.remove(element);
+    print('remove: $element | $did');
+  }
 }
 
 
 /**
  * Instances of the class [IncrementalResolver] resolve the smallest portion of
  * an AST structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
    * The element for the library containing the compilation unit being visited.
@@ skipping 286 matching lines @@
 }
 
 
 class _ElementsGatherer extends GeneralizingElementVisitor {
   final DeclarationMatcher matcher;
 
   _ElementsGatherer(this.matcher);
 
   @override
   visitElement(Element element) {
-    matcher._allElements.add(element);
-    matcher._unmatchedElements.add(element);
+    _addElement(element);
     super.visitElement(element);
   }
+
+  @override
+  visitPropertyAccessorElement(PropertyAccessorElement element) {
+    if (!element.isSynthetic) {
+      _addElement(element);
+    }
+    // Don't visit children (such as a synthetic setter parameter).
+  }
+
+  @override
+  visitPropertyInducingElement(PropertyInducingElement element) {
+    // TODO(scheglov) should we remove synthetic variable initializer?
+//    _addElement(element);
+//    element.getter.accept(this);
+//    element.setter.accept(this);
+//    _addElement(element.getter);
+//    _addElement(element.setter);
+  }
+
+  @override
+  visitTopLevelVariableElement(TopLevelVariableElement element) {
+    if (!element.isSynthetic) {
+      _addElement(element);
+    }
+  }
+
+  void _addElement(Element element) {
+    if (element != null) {
+      matcher._allElements.add(element);
+      matcher._unmatchedElements.add(element);
+    }
+  }
 }