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 80 matching lines @@
         (CompletionSuggestion cs) => cs.completion == completion,
         orElse: () => null);
     if (suggestion != null) {
       failedCompletion('did not expect completion: $completion\n  $suggestion');
     }
     return null;
   }
 
   CompletionSuggestion assertSuggest(String completion,
       {CompletionSuggestionKind csKind: CompletionSuggestionKind.INVOCATION,
-      int relevance: COMPLETION_RELEVANCE_DEFAULT,
-      protocol.ElementKind elemKind: null, bool isDeprecated: false, bool isPotential:
-      false}) {
+      int relevance: COMPLETION_RELEVANCE_DEFAULT, protocol.ElementKind elemKind:
+      null, bool isDeprecated: false, bool isPotential: false}) {
     CompletionSuggestion cs =
         getSuggest(completion: completion, csKind: csKind, elemKind: elemKind);
     if (cs == null) {
-      failedCompletion('expected $completion $csKind', request.suggestions);
+      failedCompletion(
+          'expected $completion $csKind $elemKind',
+          request.suggestions);
     }
     expect(cs.kind, equals(csKind));
     if (isDeprecated) {
       expect(cs.relevance, equals(COMPLETION_RELEVANCE_LOW));
     } else {
       expect(cs.relevance, equals(relevance));
     }
     expect(cs.selectionOffset, equals(completion.length));
     expect(cs.selectionLength, equals(0));
     expect(cs.isDeprecated, equals(isDeprecated));
@@ skipping 37 matching lines @@
     }
     StringBuffer msg = new StringBuffer();
     msg.writeln('Argument list not the same');
     msg.writeln('  Expected names: $expectedNames');
     msg.writeln('           found: $actualNames');
     msg.writeln('  Expected types: $expectedTypes');
     msg.writeln('           found: $actualTypes');
     fail(msg.toString());
   }
 
-  CompletionSuggestion assertSuggestClass(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestClass(String name, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.CLASS));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     return cs;
   }
 
-  CompletionSuggestion assertSuggestClassTypeAlias(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestClassTypeAlias(String name, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         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,
-      {int relevance: COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
-      bool isDeprecated: false}) {
+  CompletionSuggestion assertSuggestField(String name, String type,
+      {int relevance: COMPLETION_RELEVANCE_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);
+    // The returnType represents the type of a field
+    expect(cs.returnType, type != null ? type : 'dynamic');
     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');
-    }
+    // The returnType represents the type of a field
+    expect(element.returnType, type != null ? type : 'dynamic');
     return cs;
   }
 
   CompletionSuggestion assertSuggestFunction(String name, String returnType,
       bool isDeprecated, [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         isDeprecated: isDeprecated);
-    expect(cs.returnType, equals(returnType));
+    expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.FUNCTION));
     expect(element.name, equals(name));
     expect(element.isDeprecated, equals(isDeprecated));
     String param = element.parameters;
     expect(param, isNotNull);
     expect(param[0], equals('('));
     expect(param[param.length - 1], equals(')'));
     expect(
         element.returnType,
         equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   CompletionSuggestion assertSuggestFunctionTypeAlias(String name,
       String returnType, bool isDeprecated, [int relevance =
       COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
       CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         isDeprecated: isDeprecated);
-    expect(cs.returnType, equals(returnType));
+    expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.FUNCTION_TYPE_ALIAS));
     expect(element.name, equals(name));
     expect(element.isDeprecated, equals(isDeprecated));
     // TODO (danrubel) Determine why params are null
 //    String param = element.parameters;
 //    expect(param, isNotNull);
 //    expect(param[0], equals('('));
 //    expect(param[param.length - 1], equals(')'));
     // TODO (danrubel) Determine why return type is null
 //    expect(
 //        element.returnType,
 //        equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   CompletionSuggestion assertSuggestGetter(String name, String returnType,
-      {int relevance: COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
-      bool isDeprecated: false}) {
+      {int relevance: COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind:
+      CompletionSuggestionKind.INVOCATION, bool isDeprecated: false}) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         elemKind: protocol.ElementKind.GETTER,
         isDeprecated: isDeprecated);
-    expect(cs.returnType, equals(returnType));
+    expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.GETTER));
     expect(element.name, equals(name));
     //TODO (danrubel) getter should have parameters
     // but not used in code completion
     //expect(element.parameters, '()');
     expect(
         element.returnType,
         equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
-  CompletionSuggestion assertSuggestLibraryPrefix(String prefix,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestLibraryPrefix(String prefix, [int relevance
+      = COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     // Library prefix should only be suggested by ImportedComputer
     if (computer is ImportedComputer) {
       CompletionSuggestion cs =
           assertSuggest(prefix, csKind: kind, relevance: relevance);
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.LIBRARY));
       expect(element.parameters, isNull);
       expect(element.returnType, isNull);
       return cs;
     } else {
       return assertNotSuggested(prefix);
     }
   }
 
   CompletionSuggestion assertSuggestLocalVariable(String name,
       String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     // Local variables should only be suggested by LocalComputer
     if (computer is LocalComputer) {
       CompletionSuggestion cs =
           assertSuggest(name, csKind: kind, relevance: relevance);
-      expect(cs.returnType, equals(returnType));
+      expect(cs.returnType, returnType != null ? returnType : 'dynamic');
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.LOCAL_VARIABLE));
       expect(element.name, equals(name));
       expect(element.parameters, isNull);
-      expect(
-          element.returnType,
-          equals(returnType != null ? returnType : 'dynamic'));
+      expect(element.returnType, returnType != null ? returnType : 'dynamic');
       return cs;
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestMethod(String name, String declaringType,
       String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
     expect(cs.declaringType, equals(declaringType));
-    expect(cs.returnType, equals(returnType));
+    expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.METHOD));
     expect(element.name, equals(name));
     String param = element.parameters;
     expect(param, isNotNull);
     expect(param[0], equals('('));
     expect(param[param.length - 1], equals(')'));
-    expect(
-        element.returnType,
-        equals(returnType != null ? returnType : 'dynamic'));
+    expect(element.returnType, returnType != null ? returnType : 'dynamic');
     return cs;
   }
 
   CompletionSuggestion assertSuggestNamedConstructor(String name,
       String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is InvocationComputer) {
       CompletionSuggestion cs =
           assertSuggest(name, csKind: kind, relevance: relevance);
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.CONSTRUCTOR));
       expect(element.name, equals(name));
       String param = element.parameters;
       expect(param, isNotNull);
       expect(param[0], equals('('));
       expect(param[param.length - 1], equals(')'));
       expect(element.returnType, equals(returnType));
       return cs;
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestParameter(String name, String returnType,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     // Parameters should only be suggested by LocalComputer
     if (computer is LocalComputer) {
       CompletionSuggestion cs =
           assertSuggest(name, csKind: kind, relevance: relevance);
-      expect(cs.returnType, equals(returnType));
+      expect(cs.returnType, returnType != null ? returnType : 'dynamic');
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.PARAMETER));
       expect(element.name, equals(name));
       expect(element.parameters, isNull);
       expect(
           element.returnType,
           equals(returnType != null ? returnType : 'dynamic'));
       return cs;
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestSetter(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestSetter(String name, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs = assertSuggest(
         name,
         csKind: kind,
         relevance: relevance,
         elemKind: protocol.ElementKind.SETTER);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.SETTER));
     expect(element.name, equals(name));
     // TODO (danrubel) assert setter param
     //expect(element.parameters, isNull);
     // TODO (danrubel) it would be better if this was always null
     if (element.returnType != null) {
       expect(element.returnType, 'dynamic');
     }
     return cs;
   }
 
   CompletionSuggestion assertSuggestTopLevelVar(String name, String returnType,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+      [int relevance = COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     CompletionSuggestion cs =
         assertSuggest(name, csKind: kind, relevance: relevance);
-    expect(cs.returnType, equals(returnType));
+    expect(cs.returnType, returnType != null ? returnType : 'dynamic');
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.TOP_LEVEL_VARIABLE));
     expect(element.name, equals(name));
     expect(element.parameters, isNull);
-    //TODO (danrubel) return type level variable 'type' but not as 'returnType'
-//    expect(
-//        element.returnType,
-//        equals(returnType != null ? returnType : 'dynamic'));
+    expect(element.returnType, returnType != null ? returnType : 'dynamic');
     return cs;
   }
 
   void assertSuggestTopLevelVarGetterSetter(String name, String returnType,
       [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is ImportedComputer) {
       assertSuggestGetter(name, returnType);
       assertSuggestSetter(name);
     } else {
       assertNotSuggested(name);
@@ skipping 151 matching lines @@
   CompletionSuggestion assertLocalSuggestMethod(String name,
       String declaringType, String returnType, [int relevance =
       COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestImportedClass(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestImportedClass(String name, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestClass(name, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestImportedField(String name,
+  CompletionSuggestion assertSuggestImportedField(String name, String type,
       [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is ImportedComputer) {
-      return assertSuggestField(name, relevance: relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
+    return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestImportedFunction(String name,
       String returnType, [bool isDeprecated = false, int relevance =
       COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
       CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestFunction(
           name,
           returnType,
@@ skipping 15 matching lines @@
           returnType,
           isDeprecated,
           relevance,
           kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedGetter(String name,
-      String returnType, [int relevance =
-      COMPLETION_RELEVANCE_DEFAULT]) {
+      String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is ImportedComputer) {
       return assertSuggestGetter(name, returnType, relevance: relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedMethod(String name,
       String declaringType, String returnType, [int relevance =
       COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is ImportedComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestImportedSetter(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
+  CompletionSuggestion assertSuggestImportedSetter(String name, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is ImportedComputer) {
       return assertSuggestSetter(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestImportedTopLevelVar(String name,
       String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT,
       CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
     if (computer is ImportedComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance, kind);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestInvocationClass(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
+  CompletionSuggestion assertSuggestInvocationClass(String name, [int relevance
+      = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestClass(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
+  CompletionSuggestion assertSuggestInvocationField(String name, String type,
+      {int relevance: COMPLETION_RELEVANCE_DEFAULT, bool isDeprecated: false}) {
+    return assertNotSuggested(name);
+  }
+
   CompletionSuggestion assertSuggestInvocationGetter(String name,
       String returnType, {int relevance: COMPLETION_RELEVANCE_DEFAULT,
       bool isDeprecated: false}) {
     if (computer is InvocationComputer) {
       return assertSuggestGetter(
           name,
           returnType,
           relevance: relevance,
           isDeprecated: isDeprecated);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationMethod(String name,
       String declaringType, String returnType, [int relevance =
       COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestInvocationSetter(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
+  CompletionSuggestion assertSuggestInvocationSetter(String name, [int relevance
+      = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestSetter(name);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestInvocationTopLevelVar(String name,
-      String returnType, [int relevance =
-      COMPLETION_RELEVANCE_DEFAULT]) {
+      String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is InvocationComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestLocalClass(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
+  CompletionSuggestion assertSuggestLocalClass(String name, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestClass(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalClassTypeAlias(String name,
       [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestClassTypeAlias(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestLocalField(String name,
+  CompletionSuggestion assertSuggestLocalField(String name, String type,
       [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
-    if (computer is LocalComputer) {
-      return assertSuggestField(name, relevance: relevance);
-    } else {
-      return assertNotSuggested(name);
-    }
+    return assertNotSuggested(name);
   }
 
   CompletionSuggestion assertSuggestLocalFunction(String name,
       String returnType, [bool isDeprecated = false, int relevance =
       COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestFunction(name, returnType, isDeprecated, relevance);
     } else {
       return assertNotSuggested(name);
     }
@@ skipping 25 matching lines @@
   CompletionSuggestion assertSuggestLocalMethod(String name,
       String declaringType, String returnType, [int relevance =
       COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestLocalSetter(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
+  CompletionSuggestion assertSuggestLocalSetter(String name, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestSetter(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalTopLevelVar(String name,
-      String returnType, [int relevance =
-      COMPLETION_RELEVANCE_DEFAULT]) {
+      String returnType, [int relevance = COMPLETION_RELEVANCE_DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
-  CompletionSuggestion assertSuggestNonLocalClass(String name,
-      [int relevance = COMPLETION_RELEVANCE_DEFAULT,
-      CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) {
+  CompletionSuggestion assertSuggestNonLocalClass(String name, [int relevance =
+      COMPLETION_RELEVANCE_DEFAULT, CompletionSuggestionKind kind =
+      CompletionSuggestionKind.INVOCATION]) {
     return assertSuggestImportedClass(name, relevance, kind);
   }
 
   Future computeFull(assertFunction(bool result), {bool fullAnalysis: true}) {
     return super.computeFull(
         assertFunction,
         fullAnalysis: fullAnalysis).then(assertCachedCompute);
   }
 
   test_ArgumentList() {
@@ skipping 451 matching lines @@
       lib B;
       class F { var f1; f2() { } get f3 => 0; set f4(fx) { } }
       class E extends F { var e1; e2() { } }
       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) {
-      assertSuggestImportedField('e1');
-      assertSuggestImportedField('f1');
-      assertSuggestImportedField('i1');
-      assertSuggestImportedField('m1');
+      assertSuggestImportedField('e1', null);
+      assertSuggestImportedField('f1', null);
+      assertSuggestImportedField('i1', 'int');
+      assertSuggestImportedField('m1', null);
       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() { } 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) {
-      assertSuggestLocalField('e1');
-      assertSuggestLocalField('f1');
-      assertSuggestLocalField('i1');
-      assertSuggestLocalField('m1');
+      assertSuggestLocalField('e1', null);
+      assertSuggestLocalField('f1', null);
+      assertSuggestLocalField('i1', 'int');
+      assertSuggestLocalField('m1', null);
       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', '''
       class B { }''');
     addTestSource('''
       import "/testB.dart";
       class A {var b; X _c;}
       class X{}
       // looks like a cascade to the parser
       // but the user is trying to get completions for a non-cascade
       main() {A a; a.^.z}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestInvocationGetter('b', null);
-      assertSuggestInvocationGetter('_c', 'X');
+      assertSuggestInvocationField('b', null);
+      assertSuggestInvocationField('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
       assertNotSuggested('==');
     });
   }
 
   test_CascadeExpression_selector2() {
     // SimpleIdentifier  PropertyAccess  CascadeExpression  ExpressionStatement
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "/testB.dart";
       class A {var b; X _c;}
       class X{}
       main() {A a; a..^z}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestInvocationGetter('b', null);
-      assertSuggestInvocationGetter('_c', 'X');
+      assertSuggestInvocationField('b', null);
+      assertSuggestInvocationField('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
       assertNotSuggested('==');
     });
   }
 
   test_CascadeExpression_selector2_withTrailingReturn() {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "/testB.dart";
       class A {var b; X _c;}
       class X{}
       main() {A a; a..^ return}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestInvocationGetter('b', null);
-      assertSuggestInvocationGetter('_c', 'X');
+      assertSuggestInvocationField('b', null);
+      assertSuggestInvocationField('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
       assertNotSuggested('==');
     });
   }
 
   test_CascadeExpression_target() {
@@ skipping 123 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) {
-      assertSuggestLocalField('b');
-      assertSuggestLocalField('_c');
+      assertSuggestLocalField('b', null);
+      assertSuggestLocalField('_c', 'X');
       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 =
-          assertSuggestLocalField('f', COMPLETION_RELEVANCE_LOW);
+          assertSuggestLocalField('f', 'X', COMPLETION_RELEVANCE_LOW);
       if (getterF != null) {
         expect(getterF.element.isDeprecated, isTrue);
         expect(getterF.element.isPrivate, isFalse);
         expect(getterF.element.parameters, isNull);
       }
-      CompletionSuggestion getterG = assertSuggestLocalField('_g');
+      CompletionSuggestion getterG = assertSuggestLocalField('_g', null);
       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 142 matching lines @@
         m(X x) {} I _n(X x) {}}
       class X{}''');
     addTestSource('''
       import "/testB.dart";
       class A extends B {
         static const String scA = 'foo';
         w() { }}
       main() {A.^}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestInvocationGetter('scA', 'String');
-      assertSuggestInvocationGetter('scB', 'int');
-      assertSuggestInvocationGetter('scI', null);
+      assertSuggestInvocationField('scA', 'String');
+      assertSuggestInvocationField('scB', 'int');
+      assertSuggestInvocationField('scI', null);
       assertNotSuggested('b');
       assertNotSuggested('_c');
       assertNotSuggested('d');
       assertNotSuggested('_e');
       assertNotSuggested('f');
       assertNotSuggested('_g');
       assertNotSuggested('s1');
       assertNotSuggested('_s2');
       assertNotSuggested('m');
       assertNotSuggested('_n');
@@ skipping 16 matching lines @@
         @deprecated var b; X _c;
         X get d => new A();get _e => new A();
         set s1(I x) {} set _s2(I x) {}
         m(X x) {} I _n(X x) {}}
       class X{}''');
     addTestSource('''
       import "/testB.dart";
       main() {A a; a.^}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestInvocationGetter('sc', 'int');
-      assertSuggestInvocationGetter('b', null, isDeprecated: true);
+      assertSuggestInvocationField('sc', 'int');
+      assertSuggestInvocationField('b', null, isDeprecated: true);
       assertNotSuggested('_c');
       assertSuggestInvocationGetter('d', 'X');
       assertNotSuggested('_e');
       assertSuggestInvocationGetter('f', 'X');
       assertNotSuggested('_g');
       assertSuggestInvocationSetter('s1');
       assertNotSuggested('_s2');
       assertSuggestInvocationMethod('m', 'A', null);
       assertNotSuggested('_n');
       assertNotSuggested('a');
@@ skipping 11 matching lines @@
       class I {X get f => new A();get _g => new A();}
       class A implements I {
         static const int sc = 12;
         var b; X _c;
         X get d => new A();get _e => new A();
         set s1(I x) {} set _s2(I x) {}
         m(X x) {} I _n(X x) {}}
       class X{}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestInvocationGetter('sc', 'int');
-      assertSuggestInvocationGetter('b', null);
-      assertSuggestInvocationGetter('_c', 'X');
+      assertSuggestInvocationField('sc', 'int');
+      assertSuggestInvocationField('b', null);
+      assertSuggestInvocationField('_c', 'X');
       assertSuggestInvocationGetter('d', 'X');
       assertSuggestInvocationGetter('_e', null);
       assertSuggestInvocationGetter('f', 'X');
       assertSuggestInvocationGetter('_g', null);
       assertSuggestInvocationSetter('s1');
       assertSuggestInvocationSetter('_s2');
       assertSuggestInvocationMethod('m', 'A', null);
       assertSuggestInvocationMethod('_n', 'A', 'I');
       assertNotSuggested('a');
       assertNotSuggested('A');
@@ skipping 33 matching lines @@
     addSource('/testB.dart', '''
       lib B;
       class _W {M y; var _z;}
       class X extends _W {}
       class M{}''');
     addTestSource('''
       import "/testB.dart";
       foo(X x) {x.^}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestInvocationGetter('y', 'M');
+      assertSuggestInvocationField('y', 'M');
       assertNotSuggested('_z');
       assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_prefix() {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource('/testA.dart', '''
       class A {static int bar = 10;}
       _B() {}''');
@@ skipping 65 matching lines @@
         A() {}
         A.z() {}
         var b; X _c;
         X get d => new A();get _e => new A();
         // no semicolon between completion point and next statement
         set s1(I x) {} set _s2(I x) {this.^ m(null);}
         m(X x) {} I _n(X x) {}}
       class X{}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestInvocationGetter('b', null);
-      assertSuggestInvocationGetter('_c', 'X');
+      assertSuggestInvocationField('b', null);
+      assertSuggestInvocationField('_c', 'X');
       assertSuggestInvocationGetter('d', 'X');
       assertSuggestInvocationGetter('_e', null);
       assertSuggestInvocationGetter('f', 'X');
       assertSuggestInvocationGetter('_g', null);
       assertSuggestInvocationMethod('m', 'A', null);
       assertSuggestInvocationMethod('_n', 'A', 'I');
       assertSuggestInvocationSetter('s1');
       assertSuggestInvocationSetter('_s2');
       assertNotSuggested('z');
       assertNotSuggested('I');
@@ skipping 13 matching lines @@
         A() {this.^}
         A.z() {}
         var b; X _c;
         X get d => new A();get _e => new A();
         // no semicolon between completion point and next statement
         set s1(I x) {} set _s2(I x) {m(null);}
         m(X x) {} I _n(X x) {}}
       class X{}''');
     computeFast();
     return computeFull((bool result) {
-      assertSuggestInvocationGetter('b', null);
-      assertSuggestInvocationGetter('_c', 'X');
+      assertSuggestInvocationField('b', null);
+      assertSuggestInvocationField('_c', 'X');
       assertSuggestInvocationGetter('d', 'X');
       assertSuggestInvocationGetter('_e', null);
       assertSuggestInvocationGetter('f', 'X');
       assertSuggestInvocationGetter('_g', null);
       assertSuggestInvocationMethod('m', 'A', null);
       assertSuggestInvocationMethod('_n', 'A', 'I');
       assertSuggestInvocationSetter('s1');
       assertSuggestInvocationSetter('_s2');
       assertNotSuggested('z');
       assertNotSuggested('I');
@@ skipping 90 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }