suggest fields rather than synthetic getters

pkg/analysis_server/test/services/completion/completion_test_util.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 test.services.completion.util;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart' as protocol show Element,
     ElementKind;
@@ skipping 172 matching lines @@
         assertSuggest(name, csKind: kind, relevance: relevance);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.CLASS_TYPE_ALIAS));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     return cs;
   }
 
+  CompletionSuggestion assertSuggestField(String name,
+      {CompletionRelevance relevance: CompletionRelevance.DEFAULT,
+      CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
+      bool isDeprecated: false}) {
+    CompletionSuggestion cs = assertSuggest(
+        name,
+        csKind: kind,
+        relevance: relevance,
+        elemKind: protocol.ElementKind.FIELD,
+        isDeprecated: isDeprecated);
+    expect(cs.returnType, isNull);
+    protocol.Element element = cs.element;
+    expect(element, isNotNull);
+    expect(element.kind, equals(protocol.ElementKind.FIELD));
+    expect(element.name, equals(name));
+    expect(element.parameters, isNull);
+    // TODO (danrubel) return type should be null and there should be
+    // something that represents the type of the field
+    if (element.returnType != null) {
+      expect(element.returnType, 'dynamic');
+    }
+    return cs;
+  }
+
   CompletionSuggestion assertSuggestFunction(String name, String returnType,
       bool isDeprecated, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         isDeprecated: isDeprecated);
     expect(cs.returnType, equals(returnType));
     protocol.Element element = cs.element;
@@ skipping 376 matching lines @@
   CompletionSuggestion assertSuggestImportedClass(String name,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestClass(name, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
+  CompletionSuggestion assertSuggestImportedField(String name,
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+    if (computer is ImportedComputer) {
+      return assertSuggestField(name, relevance: relevance);
+    } else {
+      return assertNotSuggested(name);
+    }
+  }
+
   CompletionSuggestion assertSuggestImportedFunction(String name,
       String returnType, [bool isDeprecated = false, CompletionRelevance relevance =
       CompletionRelevance.DEFAULT, CompletionSuggestionKind kind =
       CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestFunction(
           name,
           returnType,
           isDeprecated,
           relevance,
@@ skipping 32 matching lines @@
   CompletionSuggestion assertSuggestImportedMethod(String name,
       String declaringType, String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is ImportedComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
+  CompletionSuggestion assertSuggestImportedSetter(String name,
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+    if (computer is ImportedComputer) {
+      return assertSuggestSetter(name, relevance);
+    } else {
+      return assertNotSuggested(name);
+    }
+  }
+
   CompletionSuggestion assertSuggestImportedTopLevelVar(String name,
       String returnType, [CompletionRelevance relevance = CompletionRelevance.DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
@@ skipping 60 matching lines @@
 
   CompletionSuggestion assertSuggestLocalClassTypeAlias(String name,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestClassTypeAlias(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
+  CompletionSuggestion assertSuggestLocalField(String name,
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+    if (computer is LocalComputer) {
+      return assertSuggestField(name, relevance: relevance);
+    } else {
+      return assertNotSuggested(name);
+    }
+  }
+
   CompletionSuggestion assertSuggestLocalFunction(String name,
       String returnType, [bool isDeprecated = false, CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestFunction(name, returnType, isDeprecated, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
@@ skipping 507 matching lines @@
       assertNotSuggested('==');
       // TODO (danrubel) suggest HtmlElement as low relevance
       assertNotSuggested('HtmlElement');
     });
   }
 
   test_Block_inherited_imported() {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
     addSource('/testB.dart', '''
       lib B;
-      class F { var f1; f2() { } }
+      class F { var f1; f2() { } get f3 => 0; set f4(fx) { } }
       class E extends F { var e1; e2() { } }
-      class I { int i1; i2() { } }
+      class I { int i1; i2() { } get e1; }
       class M { var m1; int m2() { } }''');
     addTestSource('''
       import "/testB.dart";
       class A extends E implements I with M {a() {^}}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestImportedGetter('e1', null);
-      assertSuggestImportedGetter('f1', null);
-      assertSuggestImportedGetter('i1', 'int');
-      assertSuggestImportedGetter('m1', null);
+      assertSuggestImportedField('e1');
+      assertSuggestImportedField('f1');
+      assertSuggestImportedField('i1');
+      assertSuggestImportedField('m1');
+      assertSuggestImportedGetter('f3', null);
+      assertSuggestImportedSetter('f4');
       //TODO (danrubel) include declared type in suggestion
       assertSuggestImportedMethod('e2', null, null);
       assertSuggestImportedMethod('f2', null, null);
       assertSuggestImportedMethod('i2', null, null);
       //assertSuggestImportedMethod('m2', null, null);
       assertNotSuggested('==');
     });
   }
 
   test_Block_inherited_local() {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
     addTestSource('''
-      class F { var f1; f2() { } }
+      class F { var f1; f2() { } get f3 => 0; set f4(fx) { } }
       class E extends F { var e1; e2() { } }
       class I { int i1; i2() { } }
       class M { var m1; int m2() { } }
       class A extends E implements I with M {a() {^}}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestLocalGetter('e1', null);
-      assertSuggestLocalGetter('f1', null);
-      assertSuggestLocalGetter('i1', 'int');
-      assertSuggestLocalGetter('m1', null);
+      assertSuggestLocalField('e1');
+      assertSuggestLocalField('f1');
+      assertSuggestLocalField('i1');
+      assertSuggestLocalField('m1');
+      assertSuggestLocalGetter('f3', null);
+      assertSuggestLocalSetter('f4');
       assertSuggestLocalMethod('e2', 'E', null);
       assertSuggestLocalMethod('f2', 'F', null);
       assertSuggestLocalMethod('i2', 'I', null);
       assertSuggestLocalMethod('m2', 'M', 'int');
     });
   }
 
   test_CascadeExpression_selector1() {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
     addSource('/testB.dart', '''
@@ skipping 189 matching lines @@
       assertNoSuggestions();
     });
   }
 
   test_ConditionalExpression_empty() {
     // SimpleIdentifier  PrefixIdentifier  IfStatement
     addTestSource('''
       class A {var b; X _c; foo() {A a; if (^) something}}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestLocalGetter('b', null);
-      assertSuggestLocalGetter('_c', 'X');
+      assertSuggestLocalField('b');
+      assertSuggestLocalField('_c');
       assertSuggestImportedClass('Object');
       assertSuggestLocalClass('A');
       assertNotSuggested('==');
     });
   }
 
   test_ConditionalExpression_invocation() {
     // SimpleIdentifier  PrefixIdentifier  IfStatement
     addTestSource('''
       main() {var a; if (a.^) something}''');
@@ skipping 481 matching lines @@
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated X f; Z _a() {^} var _g;}');
     computeFast();
     return computeFull((bool result) {
       CompletionSuggestion methodA = assertSuggestLocalMethod('_a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isTrue);
       }
       CompletionSuggestion getterF =
-          assertSuggestLocalGetter('f', 'X', CompletionRelevance.LOW);
+          assertSuggestLocalField('f', CompletionRelevance.LOW);
       if (getterF != null) {
         expect(getterF.element.isDeprecated, isTrue);
         expect(getterF.element.isPrivate, isFalse);
         expect(getterF.element.parameters, isNull);
       }
-      CompletionSuggestion getterG = assertSuggestLocalGetter('_g', null);
+      CompletionSuggestion getterG = assertSuggestLocalField('_g');
       if (getterG != null) {
         expect(getterG.element.isDeprecated, isFalse);
         expect(getterG.element.isPrivate, isTrue);
         expect(getterF.element.parameters, isNull);
       }
       assertSuggestImportedClass('bool');
     });
   }
 
   test_MethodDeclaration_parameters_named() {
@@ skipping 503 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }