Create synthetic FieldElement(s) (don't use non-synthetic ones) for non-synthetic class getters/set…

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';
@@ skipping 462 matching lines @@
     // verify delta
     expect(helper.delta.addedConstructors, isEmpty);
     expect(helper.delta.removedConstructors, isEmpty);
     expect(helper.delta.addedAccessors, isEmpty);
     expect(helper.delta.removedAccessors,
         unorderedEquals([oldFieldElementB.getter, oldFieldElementB.setter]));
     expect(helper.delta.addedMethods, isEmpty);
     expect(helper.delta.removedMethods, isEmpty);
   }
 
+  test_classDelta_field_syntheticAndNot_renameNonSynthetic() {
+    var helper = new _ClassDeltaHelper('A');
+    _buildOldUnit(r'''
+class A {
+  int foo;
+  int get foo => 1;
+}
+''');
+    helper.initOld(oldUnit);
+    FieldDeclaration oldFieldDeclNode = helper.oldMembers[0];
+    VariableDeclaration oldFieldNode = oldFieldDeclNode.fields.variables.single;
+    FieldElement oldFieldElement = oldFieldNode.name.staticElement;
+    _buildNewUnit(r'''
+class A {
+  int _foo;
+  int get foo => 1;
+}
+''');
+    helper.initNew(newUnit, unitDelta);
+    // nodes
+    FieldDeclaration newFieldDeclNode = helper.newMembers[0];
+    VariableDeclaration newFieldNode = newFieldDeclNode.fields.variables.single;
+    MethodDeclaration getterNode = helper.newMembers[1];
+    expect(getterNode, same(helper.oldMembers[1]));
+    // elements
+    FieldElement newFieldElement = newFieldNode.name.staticElement;
+    PropertyAccessorElement getterElement = getterNode.element;
+    expect(newFieldElement.name, '_foo');
+    expect(
+        helper.element.fields,
+        unorderedMatches(
+            [same(newFieldElement), same(getterElement.variable)]));
+    expect(
+        helper.element.accessors,
+        unorderedMatches([
+          same(newFieldElement.getter),
+          same(newFieldElement.setter),
+          same(getterElement)
+        ]));
+    // verify delta
+    expect(helper.delta.addedConstructors, isEmpty);
+    expect(helper.delta.removedConstructors, isEmpty);
+    expect(helper.delta.addedAccessors,
+        unorderedEquals([newFieldElement.getter, newFieldElement.setter]));
+    expect(helper.delta.removedAccessors,
+        [oldFieldElement.getter, oldFieldElement.setter]);
+    expect(helper.delta.addedMethods, isEmpty);
+    expect(helper.delta.removedMethods, isEmpty);
+  }
+
   test_classDelta_getter_add() {
     var helper = new _ClassDeltaHelper('A');
     _buildOldUnit(r'''
 class A {
   int get aaa => 1;
 }
 ''');
     helper.initOld(oldUnit);
     _buildNewUnit(r'''
 class A {
@@ skipping 1551 matching lines @@
     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);
+    _verifyEqual('$desc isSynthetic', expected.isSynthetic, actual.isSynthetic);
     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 implicit properties.
+    if (expected is PropertyAccessorElement &&
+        actual is PropertyAccessorElement &&
+        !expected.isSynthetic) {
+      _verifyElement(expected.variable, actual.variable, '$desc variable');
+    }
     // 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]');
       }
     }
@@ skipping 39 matching lines @@
           unitMember is ClassDeclaration && unitMember.name.name == name);
 }
 
 class _MaterializeLazyElementsVisitor extends GeneralizingElementVisitor {
   @override
   visitExecutableElement(ExecutableElement element) {
     element.parameters;
     super.visitExecutableElement(element);
   }
 }