insert parameters when completing imported functions and inherited methods

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();
 
 /**
- * Create a suggestion based upon the given imported element.
+ * Return a suggestion based upon the given element
+ * or `null` if a suggestion is not appropriate for the given element.
  */
-CompletionSuggestion createElementSuggestion(Element element, {int relevance:
-    COMPLETION_RELEVANCE_DEFAULT}) {
+CompletionSuggestion createSuggestion(Element element,
+    {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION,
+    int relevance: COMPLETION_RELEVANCE_DEFAULT}) {
+  DartType type;
+  if (element is ExecutableElement) {
+    if (element.isOperator) {
+      return null;
+    }
+    if (element is PropertyAccessorElement && element.isSetter) {
+      type = NO_RETURN_TYPE;
+    } else {
+      type = element.returnType;
+    }
+  } else if (element is VariableElement) {
+    type = element.type;
+  } else if (element is FunctionTypeAliasElement) {
+    type = element.returnType;
+  } else {
+    type = NO_RETURN_TYPE;
+  }
   String completion = element.displayName;
+  bool isDeprecated = element.isDeprecated;
   CompletionSuggestion suggestion = new CompletionSuggestion(
-      CompletionSuggestionKind.INVOCATION,
-      element.isDeprecated ? COMPLETION_RELEVANCE_LOW : relevance,
+      kind,
+      isDeprecated ? COMPLETION_RELEVANCE_LOW : relevance,
       completion,
       completion.length,
       0,
-      element.isDeprecated,
+      isDeprecated,
       false);
-
-  suggestion.element = newElement_fromEngine(element);
-
-  DartType type;
-  if (element is ExecutableElement) {
-    type = element.returnType;
-  } else if (element is VariableElement) {
-    type = element.type;
-  } else {
-    type = NO_RETURN_TYPE;
+  suggestion.element = protocol.newElement_fromEngine(element);
+  if (element is ClassMemberElement) {
+    ClassElement enclosingElement = element.enclosingElement;
+    if (enclosingElement != null) {
+      suggestion.declaringType = enclosingElement.displayName;
+    }
   }
   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);
+  }
   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 85 matching lines @@
   }
   //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 {
+class ClassElementSuggestionBuilder extends GeneralizingElementVisitor with
+    ElementSuggestionBuilder {
   final bool staticOnly;
+  final DartCompletionRequest request;
 
-  ClassElementSuggestionBuilder(DartCompletionRequest request, bool staticOnly)
-      : super(request, CompletionSuggestionKind.INVOCATION),
-        this.staticOnly = staticOnly;
+  ClassElementSuggestionBuilder(this.request, bool staticOnly)
+      : this.staticOnly = staticOnly;
+
+  @override
+  CompletionSuggestionKind get kind => CompletionSuggestionKind.INVOCATION;
 
   @override
   visitClassElement(ClassElement element) {
     element.visitChildren(this);
     element.allSupertypes.forEach((InterfaceType type) {
       type.element.visitChildren(this);
     });
   }
 
   @override
   visitElement(Element element) {
     // ignored
   }
 
   @override
   visitFieldElement(FieldElement element) {
     if (staticOnly && !element.isStatic) {
       return;
     }
-    _addElementSuggestion(element, element.type, element.enclosingElement);
+    addSuggestion(element);
   }
 
   @override
   visitMethodElement(MethodElement element) {
     if (staticOnly && !element.isStatic) {
       return;
     }
     if (element.isOperator) {
       return;
     }
-    _addElementSuggestion(
-        element,
-        element.returnType,
-        element.enclosingElement);
+    addSuggestion(element);
   }
 
   @override
   visitPropertyAccessorElement(PropertyAccessorElement element) {
     if (staticOnly && !element.isStatic) {
       return;
     }
-    if (element.isGetter) {
-      _addElementSuggestion(
-          element,
-          element.returnType,
-          element.enclosingElement);
-    } else if (element.isSetter) {
-      _addElementSuggestion(element, NO_RETURN_TYPE, element.enclosingElement);
-    }
+    addSuggestion(element);
   }
 
   /**
    * 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;
     }
     if (element is ClassElement) {
       return element.accept(
           new ClassElementSuggestionBuilder(request, staticOnly));
     }
   }
 }
 
 /**
+ * Common mixin for sharing behavior
+ */
+abstract class ElementSuggestionBuilder {
+
+  /**
+   * Internal collection of completions to prevent duplicate completions.
+   */
+  final Set<String> _completions = new Set<String>();
+
+  /**
+   * Return the kind of suggestions that should be built.
+   */
+  CompletionSuggestionKind get kind;
+
+  /**
+   * Return the request on which the builder is operating.
+   */
+  DartCompletionRequest get request;
+
+  /**
+   * Add a suggestion based upon the given element.
+   */
+  void addSuggestion(Element element) {
+    if (element.isPrivate) {
+      LibraryElement elementLibrary = element.library;
+      LibraryElement unitLibrary = request.unit.element.library;
+      if (elementLibrary != unitLibrary) {
+        return;
+      }
+    }
+    if (element.isSynthetic) {
+      if (element is PropertyAccessorElement || element is FieldElement) {
+        return;
+      }
+    }
+    String completion = element.displayName;
+    if (completion == null ||
+        completion.length <= 0 ||
+        !_completions.add(completion)) {
+      return;
+    }
+    CompletionSuggestion suggestion = createSuggestion(element, kind: kind);
+    if (suggestion != null) {
+      request.suggestions.add(suggestion);
+    }
+  }
+}
+
+/**
  * This class visits elements in a library and provides suggestions based upon
  * the visible members in that library. Clients should call
  * [LibraryElementSuggestionBuilder.suggestionsFor].
  */
-class LibraryElementSuggestionBuilder extends _AbstractSuggestionBuilder {
+class LibraryElementSuggestionBuilder extends GeneralizingElementVisitor with
+    ElementSuggestionBuilder {
+  final DartCompletionRequest request;
+  final CompletionSuggestionKind kind;
 
-  LibraryElementSuggestionBuilder(DartCompletionRequest request,
-      CompletionSuggestionKind kind)
-      : super(request, kind);
+  LibraryElementSuggestionBuilder(this.request, this.kind);
 
   @override
   visitClassElement(ClassElement element) {
-    _addElementSuggestion(element, NO_RETURN_TYPE, null);
+    addSuggestion(element);
   }
 
   @override
   visitCompilationUnitElement(CompilationUnitElement element) {
     element.visitChildren(this);
   }
 
   @override
   visitElement(Element element) {
     // ignored
   }
 
   @override
   visitFunctionElement(FunctionElement element) {
-    _addElementSuggestion(element, element.returnType, null);
+    addSuggestion(element);
   }
 
   @override
   visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
-    _addElementSuggestion(element, element.returnType, null);
+    addSuggestion(element);
   }
 
   @override
   visitTopLevelVariableElement(TopLevelVariableElement element) {
-    _addElementSuggestion(element, element.type, null);
+    addSuggestion(element);
   }
 
   /**
    * Add suggestions for the visible members in the given library
    */
   static void suggestionsFor(DartCompletionRequest request,
       CompletionSuggestionKind kind, LibraryElement library) {
     if (library != null) {
       library.visitChildren(new LibraryElementSuggestionBuilder(request, kind));
     }
   }
 }
 
 /**
  * This class visits elements in a class and provides suggestions based upon
  * the visible named constructors in that class.
  */
-class NamedConstructorSuggestionBuilder extends _AbstractSuggestionBuilder
-    implements SuggestionBuilder {
+class NamedConstructorSuggestionBuilder extends GeneralizingElementVisitor with
+    ElementSuggestionBuilder implements SuggestionBuilder {
+  final DartCompletionRequest request;
 
-  NamedConstructorSuggestionBuilder(DartCompletionRequest request)
-      : super(request, CompletionSuggestionKind.INVOCATION);
+  NamedConstructorSuggestionBuilder(this.request);
+
+  @override
+  CompletionSuggestionKind get kind => CompletionSuggestionKind.INVOCATION;
 
   @override
   bool computeFast(AstNode node) {
     return false;
   }
 
   @override
   Future<bool> computeFull(AstNode node) {
     if (node is SimpleIdentifier) {
       node = node.parent;
@@ skipping 13 matching lines @@
     return new Future.value(false);
   }
 
   @override
   visitClassElement(ClassElement element) {
     element.visitChildren(this);
   }
 
   @override
   visitConstructorElement(ConstructorElement element) {
-    _addElementSuggestion(
-        element,
-        element.returnType,
-        element.enclosingElement);
+    addSuggestion(element);
   }
 
   @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 (enclosingElement != null) {
-      suggestion.declaringType = enclosingElement.displayName;
-    }
-    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;
@@ skipping 29 matching lines @@
   bool isSubtypeOf(DartType type) => false;
 
   @override
   bool isSupertypeOf(DartType type) => false;
 
   @override
   DartType substitute2(List<DartType> argumentTypes,
       List<DartType> parameterTypes) =>
       this;
 }