New analyzer snapshot.

pkg/analyzer/lib/src/generated/ast.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast;
 
 import 'dart:collection';
@@ skipping 12706 matching lines @@
     }
     if (parent is LibraryIdentifier) {
       AstNode grandParent = parent.parent;
       if (grandParent is PartOfDirective) {
         Element element = grandParent.element;
         if (element is LibraryElement) {
           return element.definingCompilationUnit;
         }
       }
     }
-    Element element = node.bestElement;
-    if (element == null) {
-      element = node.staticElement;
-    }
-    return element;
+    return node.bestElement;
   }
 
   @override
   Element visitImportDirective(ImportDirective node) => node.element;
 
   @override
   Element visitIndexExpression(IndexExpression node) => node.bestElement;
 
   @override
   Element visitInstanceCreationExpression(InstanceCreationExpression node) => node.staticElement;
@@ skipping 3173 matching lines @@
   @override
   SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(_cloneNodeList(node.labels), node.keyword, _cloneNode(node.expression), node.colon, _cloneNodeList(node.statements));
 
   @override
   SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(_cloneNodeList(node.labels), node.keyword, node.colon, _cloneNodeList(node.statements));
 
   @override
   SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement(node.keyword, node.leftParenthesis, _cloneNode(node.expression), node.rightParenthesis, node.leftBracket, _cloneNodeList(node.members), node.rightBracket);
 
   @override
-  AstNode visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral(node.poundSign, node.components);
+  SymbolLiteral visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral(node.poundSign, node.components);
 
   @override
   ThisExpression visitThisExpression(ThisExpression node) => new ThisExpression(node.keyword);
 
   @override
   ThrowExpression visitThrowExpression(ThrowExpression node) => new ThrowExpression(node.keyword, _cloneNode(node.expression));
 
   @override
   TopLevelVariableDeclaration visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _cloneNode(node.variables), node.semicolon);
 
@@ skipping 49 matching lines @@
  * they are equal.
  */
 class AstComparator implements AstVisitor<bool> {
   /**
    * Return `true` if the two AST nodes are equal.
    *
    * @param first the first node being compared
    * @param second the second node being compared
    * @return `true` if the two AST nodes are equal
    */
-  static bool equalUnits(CompilationUnit first, CompilationUnit second) {
+  static bool equalNodes(AstNode first, AstNode second) {
     AstComparator comparator = new AstComparator();
     return comparator._isEqualNodes(first, second);
   }
 
   /**
    * The AST node with which the node being visited is to be compared. This is only valid at the
    * beginning of each visit method (until [isEqualNodes] is invoked).
    */
   AstNode _other;
 
@@ skipping 669 matching lines @@
    * @param second the second node being compared
    * @return `true` if the given arrays of tokens have the same length and corresponding
    *         elements are equal
    */
   bool _isEqualTokenLists(List<Token> first, List<Token> second) {
     int length = first.length;
     if (second.length != length) {
       return false;
     }
     for (int i = 0; i < length; i++) {
-      if (_isEqualTokens(first[i], second[i])) {
+      if (!_isEqualTokens(first[i], second[i])) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Return `true` if the given tokens have the same structure.
    *
    * @param first the first node being compared
    * @param second the second node being compared
    * @return `true` if the given tokens have the same structure
    */
   bool _isEqualTokens(Token first, Token second) {
     if (first == null) {
       return second == null;
     } else if (second == null) {
       return false;
+    } else if (identical(first, second)) {
+      return true;
     }
     return first.offset == second.offset && first.length == second.length && first.lexeme == second.lexeme;
   }
 }
 
 /**
  * Instances of the class `IncrementalAstCloner` implement 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.
@@ skipping 920 matching lines @@
     _elements[index] = node;
   }
   void clear() {
     _elements = <E> [];
   }
   int get length => _elements.length;
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 }