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

pkg/analyzer/test/generated/all_the_rest_test.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.test.generated.all_the_rest_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 1573 matching lines @@
     expect(method.labels, hasLength(0));
     expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(0));
     expect(method.typeParameters, hasLength(0));
     expect(method.isAbstract, isTrue);
     expect(method.isExternal, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
+  void test_visitMethodDeclaration_duplicateField_synthetic() {
+    buildElementsForText(r'''
+class A {
+  int f;
+  int get f => 42;
+}
+''');
+    ClassDeclaration classNode = compilationUnit.declarations.single;
+    // ClassElement
+    ClassElement classElement = classNode.element;
+    expect(classElement.fields, hasLength(2));
+    expect(classElement.accessors, hasLength(3));
+    FieldElement notSyntheticFieldElement = classElement.fields
+        .singleWhere((f) => f.displayName == 'f' && !f.isSynthetic);
+    FieldElement syntheticFieldElement = classElement.fields
+        .singleWhere((f) => f.displayName == 'f' && f.isSynthetic);
+    PropertyAccessorElement syntheticGetterElement = classElement.accessors
+        .singleWhere(
+            (a) => a.displayName == 'f' && a.isGetter && a.isSynthetic);
+    PropertyAccessorElement syntheticSetterElement = classElement.accessors
+        .singleWhere(
+            (a) => a.displayName == 'f' && a.isSetter && a.isSynthetic);
+    PropertyAccessorElement notSyntheticGetterElement = classElement.accessors
+        .singleWhere(
+            (a) => a.displayName == 'f' && a.isGetter && !a.isSynthetic);
+    expect(notSyntheticFieldElement.getter, same(syntheticGetterElement));
+    expect(notSyntheticFieldElement.setter, same(syntheticSetterElement));
+    expect(syntheticFieldElement.getter, same(notSyntheticGetterElement));
+    expect(syntheticFieldElement.setter, isNull);
+    // class members nodes and their elements
+    FieldDeclaration fieldDeclNode = classNode.members[0];
+    VariableDeclaration fieldNode = fieldDeclNode.fields.variables.single;
+    MethodDeclaration getterNode = classNode.members[1];
+    expect(fieldNode.element, notSyntheticFieldElement);
+    expect(getterNode.element, notSyntheticGetterElement);
+  }
+
   void test_visitMethodDeclaration_external() {
     // external m();
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
@@ skipping 954 matching lines @@
         null,
         null,
         AstFactory.identifier3("main"),
         AstFactory.formalParameterList([formalParameter]),
         body);
   }
 }
 
 @reflectiveTest
 class ElementLocatorTest extends ResolverTestCase {
-  void test_locate_ExportDirective() {
-    AstNode id = _findNodeIn("export", "export 'dart:core';");
-    Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ExportElement, ExportElement, element);
-  }
-
-  void test_locate_Identifier_libraryDirective() {
-    AstNode id = _findNodeIn("foo", "library foo.bar;");
-    Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is LibraryElement, LibraryElement, element);
-  }
-
   void fail_locate_Identifier_partOfDirective() {
     // Can't resolve the library element without the library declaration.
     //    AstNode id = findNodeIn("foo", "part of foo.bar;");
     //    Element element = ElementLocator.locate(id);
     //    assertInstanceOf(LibraryElement.class, element);
     fail("Test this case");
   }
 
   @override
   void reset() {
@@ skipping 44 matching lines @@
 class A {
   A.bar() {}
 }''');
     ConstructorDeclaration declaration =
         id.getAncestor((node) => node is ConstructorDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement, ConstructorElement, element);
   }
 
+  void test_locate_ExportDirective() {
+    AstNode id = _findNodeIn("export", "export 'dart:core';");
+    Element element = ElementLocator.locate(id);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is ExportElement, ExportElement, element);
+  }
+
   void test_locate_FunctionDeclaration() {
     AstNode id = _findNodeIn("f", "int f() => 3;");
     FunctionDeclaration declaration =
         id.getAncestor((node) => node is FunctionDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionElement, FunctionElement, element);
   }
 
   void
@@ skipping 61 matching lines @@
         (obj) => obj is ConstructorElement, ConstructorElement, element);
   }
 
   void test_locate_Identifier_fieldName() {
     AstNode id = _findNodeIn("x", "class A { var x; }");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FieldElement, FieldElement, element);
   }
 
+  void test_locate_Identifier_libraryDirective() {
+    AstNode id = _findNodeIn("foo", "library foo.bar;");
+    Element element = ElementLocator.locate(id);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is LibraryElement, LibraryElement, element);
+  }
+
   void test_locate_Identifier_propertyAccess() {
     AstNode id = _findNodeIn(
         "length",
         r'''
 void main() {
  int x = 'foo'.length;
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyAccessorElement,
         PropertyAccessorElement, element);
@@ skipping 723 matching lines @@
   }
 
   void test_conditionalCall_rhs2() {
     _assertFalse("null?.b(throw '');");
   }
 
   void test_creation() {
     expect(new ExitDetector(), isNotNull);
   }
 
-  void test_doStatement_return() {
-    _assertTrue("{ do { return null; } while (1 == 2); }");
-  }
-
-  void test_doStatement_throwCondition() {
-    _assertTrue("{ do {} while (throw ''); }");
-  }
-
   void test_doStatement_break_and_throw() {
     _assertFalse("{ do { if (1==1) break; throw 'T'; } while (0==1); }");
   }
 
   void test_doStatement_continue_and_throw() {
     _assertFalse("{ do { if (1==1) continue; throw 'T'; } while (0==1); }");
   }
 
-  void test_doStatement_continueInSwitch_and_throw() {
+  void test_doStatement_continueDoInSwitch_and_throw() {
     _assertFalse('''
 {
-  do {
+  D: do {
     switch (1) {
-      L: case 0: continue;
+      L: case 0: continue D;
       M: case 1: break;
     }
     throw 'T';
   } while (0 == 1);
 }''');
   }
 
-  void test_doStatement_continueDoInSwitch_and_throw() {
+  void test_doStatement_continueInSwitch_and_throw() {
     _assertFalse('''
 {
-  D: do {
+  do {
     switch (1) {
-      L: case 0: continue D;
+      L: case 0: continue;
       M: case 1: break;
     }
     throw 'T';
   } while (0 == 1);
 }''');
   }
 
+  void test_doStatement_return() {
+    _assertTrue("{ do { return null; } while (1 == 2); }");
+  }
+
+  void test_doStatement_throwCondition() {
+    _assertTrue("{ do {} while (throw ''); }");
+  }
+
   void test_doStatement_true_break() {
     _assertFalse("{ do { break; } while (true); }");
   }
 
   void test_doStatement_true_continue() {
     _assertTrue("{ do { continue; } while (true); }");
   }
 
   void test_doStatement_true_continueWithLabel() {
     _assertTrue("{ x: do { continue x; } while (true); }");
   }
 
-
   void test_doStatement_true_if_return() {
     _assertTrue("{ do { if (true) {return null;} } while (true); }");
   }
 
   void test_doStatement_true_noBreak() {
     _assertTrue("{ do {} while (true); }");
   }
 
   void test_doStatement_true_return() {
     _assertTrue("{ do { return null; } while (true);  }");
@@ skipping 382 matching lines @@
   }
 
   void test_whileStatement_throwCondition() {
     _assertTrue("{ while (throw '') {} }");
   }
 
   void test_whileStatement_true_break() {
     _assertFalse("{ while (true) { break; } }");
   }
 
+  void test_whileStatement_true_break_and_throw() {
+    _assertFalse("{ while (true) { if (1==1) break; throw 'T'; } }");
+  }
+
   void test_whileStatement_true_continue() {
     _assertTrue("{ while (true) { continue; } }");
   }
 
   void test_whileStatement_true_continueWithLabel() {
     _assertTrue("{ x: while (true) { continue x; } }");
   }
 
   void test_whileStatement_true_doStatement_scopeRequired() {
     _assertTrue("{ while (true) { x: do { continue x; } while (true); } }");
   }
 
   void test_whileStatement_true_if_return() {
     _assertTrue("{ while (true) { if (true) {return null;} } }");
   }
 
   void test_whileStatement_true_noBreak() {
     _assertTrue("{ while (true) {} }");
   }
 
   void test_whileStatement_true_return() {
     _assertTrue("{ while (true) { return null; } }");
   }
 
   void test_whileStatement_true_throw() {
     _assertTrue("{ while (true) { throw ''; } }");
   }
 
-  void test_whileStatement_true_break_and_throw() {
-    _assertFalse("{ while (true) { if (1==1) break; throw 'T'; } }");
-  }
-
   void _assertFalse(String source) {
     _assertHasReturn(false, source);
   }
 
   void _assertHasReturn(bool expectedResult, String source) {
     Statement statement = ParserTestCase.parseStatement(source);
     expect(ExitDetector.exits(statement), expectedResult);
   }
 
   void _assertTrue(String source) {
@@ skipping 109 matching lines @@
     if (1 < 2) {
       break x;
     }
     return;
   }
 }
 ''');
     _assertNthStatementDoesNotExit(source, 0);
   }
 
-  void test_whileStatement_switchWithBreakWithLabel() {
-    Source source = addSource(r'''
-void f() {
-  x: while (true) {
-    switch (true) {
-      case false: break;
-      case true: break x;
-    }
-  }
-}
-''');
-    _assertNthStatementDoesNotExit(source, 0);
-  }
-
   void test_whileStatement_breakWithLabel_afterExting() {
     Source source = addSource(r'''
 void f() {
   x: while (true) {
     return;
     if (1 < 2) {
       break x;
     }
   }
 }
 ''');
     _assertNthStatementExits(source, 0);
   }
 
+  void test_whileStatement_switchWithBreakWithLabel() {
+    Source source = addSource(r'''
+void f() {
+  x: while (true) {
+    switch (true) {
+      case false: break;
+      case true: break x;
+    }
+  }
+}
+''');
+    _assertNthStatementDoesNotExit(source, 0);
+  }
+
   void test_yieldStatement_plain() {
     Source source = addSource(r'''
 void f() sync* {
   yield 1;
 }
 ''');
     _assertNthStatementDoesNotExit(source, 0);
   }
 
   void test_yieldStatement_star_plain() {
@@ skipping 382 matching lines @@
     expect(UriKind.fromEncoding(0x70), same(UriKind.PACKAGE_URI));
     expect(UriKind.fromEncoding(0x58), same(null));
   }
 
   void test_getEncoding() {
     expect(UriKind.DART_URI.encoding, 0x64);
     expect(UriKind.FILE_URI.encoding, 0x66);
     expect(UriKind.PACKAGE_URI.encoding, 0x70);
   }
 }