suggest fields rather than synthetic getters

pkg/analysis_server/lib/src/services/completion/suggestion_builder.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 services.completion.suggestion.builder;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol_server.dart' as protocol;
 import 'package:analysis_server/src/protocol_server.dart' hide Element,
     ElementKind;
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
+final DYNAMIC = 'dynamic';
+final DartType NO_RETURN_TYPE = new _NoReturnType();

[Paul Berry, 2015/01/12 17:29:20]

_LocalVisitor
(pkg/analysis_server/lib/src/services/completion/local_computer.dart) defines
NO_RETURN_TYPE as new TypeName(new SimpleIdentifier(new
StringToken(TokenType.IDENTIFIER, '', 0)), null).  We shouldn't have redundant
definitions.  I'd recommend removing the definition in local_computer.dart and
changing that file to refer to the definition here.

[danrubel, 2015/01/12 19:01:13]

That is definitely my long term intent, but these constants are two different
types so the refactoring is a bit more complex than a simple replacement. I'll
handle this in a separate CL.

[Paul Berry, 2015/01/12 19:02:55]

Ah, ok.  I understand now.  In that case, lgtm as is.

+
 /**
  * Create a suggestion based upon the given imported element.
  */
-CompletionSuggestion createElementSuggestion(Element element,
-    {int relevance: COMPLETION_RELEVANCE_DEFAULT}) {
+CompletionSuggestion createElementSuggestion(Element element, {int relevance:
+    COMPLETION_RELEVANCE_DEFAULT}) {
   String completion = element.displayName;
   CompletionSuggestion suggestion = new CompletionSuggestion(
       CompletionSuggestionKind.INVOCATION,
       element.isDeprecated ? COMPLETION_RELEVANCE_LOW : relevance,
       completion,
       completion.length,
       0,
       element.isDeprecated,
       false);
 
   suggestion.element = newElement_fromEngine(element);
 
   DartType type;
-  if (element is FunctionElement) {
+  if (element is ExecutableElement) {
     type = element.returnType;
-  } else if (element is PropertyAccessorElement && element.isGetter) {
-    type = element.returnType;
-  } else if (element is TopLevelVariableElement) {
+  } else if (element is VariableElement) {
     type = element.type;
+  } else {
+    type = NO_RETURN_TYPE;
   }
-  if (type != null) {
-    String name = type.displayName;
-    if (name != null && name.length > 0 && name != 'dynamic') {
-      suggestion.returnType = name;
-    }
-  }
+  suggestion.returnType = _nameForType(type);
   return suggestion;
 }
 
 /**
  * Call the given function with each non-null non-empty inherited type name
  * that is defined in the given class.
  */
 visitInheritedTypeNames(ClassDeclaration node, void inherited(String name)) {
 
   void visit(TypeName type) {
@@ skipping 63 matching lines @@
           todo.add(classNode);
         } else {
           imported(name);
         }
       }
     });
   }
 }
 
 /**
+   * Return the name for the given type.
+   */
+String _nameForType(DartType type) {
+  if (type == NO_RETURN_TYPE) {
+    return null;
+  }
+  if (type == null) {
+    return DYNAMIC;
+  }
+  String name = type.displayName;
+  if (name == null || name.length <= 0) {
+    return DYNAMIC;
+  }
+  //TODO (danrubel) include type arguments ??
+  return name;
+}
+
+/**
  * This class visits elements in a class and provides suggestions based upon
  * the visible members in that class. Clients should call
  * [ClassElementSuggestionBuilder.suggestionsFor].
  */
 class ClassElementSuggestionBuilder extends _AbstractSuggestionBuilder {
   final bool staticOnly;
 
   ClassElementSuggestionBuilder(DartCompletionRequest request, bool staticOnly)
       : super(request, CompletionSuggestionKind.INVOCATION),
         this.staticOnly = staticOnly;
@@ skipping 37 matching lines @@
   visitPropertyAccessorElement(PropertyAccessorElement element) {
     if (staticOnly && !element.isStatic) {
       return;
     }
     if (element.isGetter) {
       _addElementSuggestion(
           element,
           element.returnType,
           element.enclosingElement);
     } else if (element.isSetter) {
-      _addElementSuggestion(
-          element,
-          element.returnType,
-          element.enclosingElement);
+      _addElementSuggestion(element, NO_RETURN_TYPE, element.enclosingElement);
     }
   }
 
   /**
    * Add suggestions for the visible members in the given class
    */
   static void suggestionsFor(DartCompletionRequest request, Element element,
       {bool staticOnly: false}) {
     if (element == DynamicElementImpl.instance) {
       element = request.cache.objectClassElement;
@@ skipping 11 matching lines @@
  * [LibraryElementSuggestionBuilder.suggestionsFor].
  */
 class LibraryElementSuggestionBuilder extends _AbstractSuggestionBuilder {
 
   LibraryElementSuggestionBuilder(DartCompletionRequest request,
       CompletionSuggestionKind kind)
       : super(request, kind);
 
   @override
   visitClassElement(ClassElement element) {
-    _addElementSuggestion(element, null, null);
+    _addElementSuggestion(element, NO_RETURN_TYPE, null);
   }
 
   @override
   visitCompilationUnitElement(CompilationUnitElement element) {
     element.visitChildren(this);
   }
 
   @override
   visitElement(Element element) {
     // ignored
@@ skipping 71 matching lines @@
         element,
         element.returnType,
         element.enclosingElement);
   }
 
   @override
   visitElement(Element element) {
     // ignored
   }
 }
-
 /**
  * Common interface implemented by suggestion builders.
  */
 abstract class SuggestionBuilder {
   /**
    * Compute suggestions and return `true` if building is complete,
    * or `false` if [computeFull] should be called.
    */
   bool computeFast(AstNode node);
 
   /**
    * Return a future that computes the suggestions given a fully resolved AST.
    * The future returns `true` if suggestions were added, else `false`.
    */
   Future<bool> computeFull(AstNode node);
 }
 
 /**
  * Common superclass for sharing behavior
  */
 class _AbstractSuggestionBuilder extends GeneralizingElementVisitor {
   final DartCompletionRequest request;
   final CompletionSuggestionKind kind;
   final Set<String> _completions = new Set<String>();
 
   _AbstractSuggestionBuilder(this.request, this.kind);
 
+  /**
+   * Add a suggestion based upon the given element.
+   */
   void _addElementSuggestion(Element element, DartType type,
       ClassElement enclosingElement) {
     if (element.isSynthetic) {
       return;
     }
     if (element.isPrivate) {
       LibraryElement elementLibrary = element.library;
       LibraryElement unitLibrary = request.unit.element.library;
       if (elementLibrary != unitLibrary) {
         return;
       }
     }
     String completion = element.displayName;
     if (completion == null ||
         completion.length <= 0 ||
         !_completions.add(completion)) {
       return;
     }
     bool isDeprecated = element.isDeprecated;
     CompletionSuggestion suggestion = new CompletionSuggestion(
         kind,
         isDeprecated ? COMPLETION_RELEVANCE_LOW : COMPLETION_RELEVANCE_DEFAULT,
         completion,
         completion.length,
         0,
         isDeprecated,
         false);
     suggestion.element = protocol.newElement_fromEngine(element);
-    if (suggestion.element != null) {
-      if (element is FieldElement) {
-        suggestion.element.kind = protocol.ElementKind.GETTER;
-        suggestion.element.returnType =
-            element.type != null ? element.type.displayName : 'dynamic';
-      }
-    }
     if (enclosingElement != null) {
       suggestion.declaringType = enclosingElement.displayName;
     }
-    if (type != null) {
-      String typeName = type.displayName;
-      if (typeName != null && typeName.length > 0 && typeName != 'dynamic') {
-        suggestion.returnType = typeName;
-      }
-    }
+    suggestion.returnType = _nameForType(type);
     if (element is ExecutableElement && element is! PropertyAccessorElement) {
       suggestion.parameterNames = element.parameters.map(
           (ParameterElement parameter) => parameter.name).toList();
       suggestion.parameterTypes = element.parameters.map(
           (ParameterElement parameter) => parameter.type.displayName).toList();
       suggestion.requiredParameterCount = element.parameters.where(
           (ParameterElement parameter) =>
               parameter.parameterKind == ParameterKind.REQUIRED).length;
       suggestion.hasNamedParameters = element.parameters.any(
           (ParameterElement parameter) => parameter.parameterKind == ParameterKind.NAMED);
     }
     request.suggestions.add(suggestion);
   }
 }
+
+class _NoReturnType extends DartType {
+
+  @override
+  String get displayName => name;
+
+  @override
+  Element get element => null;
+
+  @override
+  bool get isBottom => false;
+
+  @override
+  bool get isDartCoreFunction => false;
+
+  @override
+  bool get isDynamic => false;
+
+  @override
+  bool get isObject => false;
+
+  @override
+  bool get isUndefined => false;
+
+  @override
+  bool get isVoid => false;
+
+  @override
+  String get name => 'NoReturnType';
+
+  @override
+  DartType getLeastUpperBound(DartType type) => this;
+
+  @override
+  bool isAssignableTo(DartType type) => type is _NoReturnType;
+
+  @override
+  bool isMoreSpecificThan(DartType type) => false;
+
+  @override
+  bool isSubtypeOf(DartType type) => false;
+
+  @override
+  bool isSupertypeOf(DartType type) => false;
+
+  @override
+  DartType substitute2(List<DartType> argumentTypes,
+      List<DartType> parameterTypes) =>
+      this;
+}