Fixes for updating synthetic element offsets.

pkg/analyzer/test/src/task/incremental_element_builder_test.dart

 // Copyright (c) 2015, 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.test.src.task.incremental_element_builder_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.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/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/incremental_element_builder.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../reflective_tests.dart';
@@ skipping 1749 matching lines @@
 /// [c)
 class A {}
 ''');
     _buildNewUnit(r'''
 int a;
 /// [c)
 class A {}
 ''');
   }
 
+  test_update_element_implicitAccessors_classField() {
+    _buildOldUnit(r'''
+// 0
+class A {
+  var F = 0;
+}
+''');
+    _materializeLazyElements(unitElement);
+    _buildNewUnit(r'''
+// 012
+class A {
+  var F = 0;
+}
+''');
+  }
+
+  test_update_element_implicitAccessors_topLevelVariable() {
+    _buildOldUnit(r'''
+var A = 0;
+var B = 1;
+''');
+    _materializeLazyElements(unitElement);
+    _buildNewUnit(r'''
+var B = 1;
+''');
+  }
+
   test_update_rewrittenConstructorName() {
     _buildOldUnit(r'''
 class A {
   A();
   A.named();
 }
 
 foo() {}
 
 main() {
@@ skipping 49 matching lines @@
     this.oldCode = oldCode;
     source = newSource('/test.dart', oldCode);
     if (libSource == null) {
       libSource = source;
     }
     oldUnit = context.resolveCompilationUnit2(source, libSource);
     unitElement = oldUnit.element;
     expect(unitElement, isNotNull);
   }
 
+  void _materializeLazyElements(CompilationUnitElement unitElement) {
+    unitElement.accept(new _MaterializeLazyElementsVisitor());
+  }
+
   void _verifyNoClassDeltaForTheLast(String oldCode, String newCode) {
     _buildOldUnit(oldCode);
     List<CompilationUnitMember> oldMembers = oldUnit.declarations.toList();
     Element oldElementLast = oldMembers.last.element;
     _buildNewUnit(newCode);
     List<CompilationUnitMember> newMembers = newUnit.declarations;
     Element newElementLast = newMembers.last.element;
     expect(newElementLast, isNot(same(oldElementLast)));
     expect(unitDelta.classDeltas, isEmpty);
     expect(unitDelta.removedDeclarations, unorderedEquals([oldElementLast]));
     expect(unitDelta.addedDeclarations, unorderedEquals([newElementLast]));
   }
 }
 
 /**
  * Compares tokens and ASTs, and built elements of declared identifiers.
  */
 class _BuiltElementsValidator extends AstComparator {
+  final Set visited = new Set.identity();
+
   @override
   bool isEqualNodes(AstNode expected, AstNode actual) {
     // Elements of nodes which are children of ClassDeclaration(s) must be
     // linked to the corresponding ClassElement(s).
     if (actual is TypeParameter) {
       TypeParameterElement element = actual.element;
       ClassDeclaration classNode = actual.parent.parent;
       expect(element.enclosingElement, same(classNode.element));
     } else if (actual is FieldDeclaration) {
       for (VariableDeclaration field in actual.fields.variables) {
@@ skipping 41 matching lines @@
     bool result = super.isEqualNodes(expected, actual);
     if (!result) {
       fail('|$actual| != expected |$expected|');
     }
     // Verify that declared identifiers have equal elements.
     if (expected is SimpleIdentifier && actual is SimpleIdentifier) {
       if (expected.inDeclarationContext()) {
         expect(actual.inDeclarationContext(), isTrue);
         Element expectedElement = expected.staticElement;
         Element actualElement = actual.staticElement;
-        _verifyElement(expectedElement, actualElement, 'staticElement');
+        _verifyElement(
+            expectedElement, actualElement, 'staticElement ($expectedElement)');
       }
     }
     return true;
   }
 
   void _verifyElement(Element expected, Element actual, String desc) {
+    if (!visited.add(expected)) {
+      return;
+    }
     if (expected == null && actual == null) {
       return;
     }
     // Prefixes are built later.
     if (actual is PrefixElement) {
       return;
     }
     // Compare properties.
     _verifyEqual('$desc name', expected.name, actual.name);
     _verifyEqual('$desc nameOffset', expected.nameOffset, actual.nameOffset);
     if (expected is ElementImpl && actual is ElementImpl) {
       _verifyEqual('$desc codeOffset', expected.codeOffset, actual.codeOffset);
       _verifyEqual('$desc codeLength', expected.codeLength, actual.codeLength);
     }
     if (expected is LocalElement && actual is LocalElement) {
       _verifyEqual(
           '$desc visibleRange', expected.visibleRange, actual.visibleRange);
     }
     _verifyEqual('$desc documentationComment', expected.documentationComment,
         actual.documentationComment);
     {
       var expectedEnclosing = expected.enclosingElement;
       var actualEnclosing = actual.enclosingElement;
       if (expectedEnclosing != null) {
         expect(actualEnclosing, isNotNull, reason: '$desc enclosingElement');
         _verifyElement(expectedEnclosing, actualEnclosing,
             '${expectedEnclosing.name}.$desc');
       }
     }
+    // Compare implicit accessors.
+    if (expected is PropertyInducingElement &&
+        actual is PropertyInducingElement &&
+        !expected.isSynthetic) {
+      _verifyElement(expected.getter, actual.getter, '$desc getter');
+      _verifyElement(expected.setter, actual.setter, '$desc setter');
+    }
+    // Compare parameters.
+    if (expected is ExecutableElement && actual is ExecutableElement) {
+      List<ParameterElement> actualParameters = actual.parameters;
+      List<ParameterElement> expectedParameters = expected.parameters;
+      expect(actualParameters, hasLength(expectedParameters.length));
+      for (int i = 0; i < expectedParameters.length; i++) {
+        _verifyElement(
+            expectedParameters[i], actualParameters[i], '$desc parameters[$i]');
+      }
+    }
   }
 
   void _verifyEqual(String name, expected, actual) {
     if (actual != expected) {
       fail('$name\nExpected: $expected\n  Actual: $actual');
     }
   }
 }
 
 class _ClassDeltaHelper {
@@ skipping 21 matching lines @@
     expect(oldClass, isNotNull);
     element = oldClass.element;
     oldVersion = element.version;
     oldMembers = oldClass.members.toList();
   }
 
   ClassDeclaration _findClassNode(CompilationUnit unit, String name) =>
       unit.declarations.singleWhere((unitMember) =>
           unitMember is ClassDeclaration && unitMember.name.name == name);
 }
+
+class _MaterializeLazyElementsVisitor extends GeneralizingElementVisitor {
+  @override
+  visitExecutableElement(ExecutableElement element) {
+    element.parameters;
+    super.visitExecutableElement(element);
+  }
+}