add local parameter info to completion suggestions

pkg/analysis_server/lib/src/services/completion/local_computer.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.computer.dart.local;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart' as protocol show Element,
     ElementKind;
 import 'package:analysis_server/src/protocol.dart' hide Element, ElementKind;
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analysis_server/src/services/completion/local_declaration_visitor.dart';
 import 'package:analysis_server/src/services/completion/optype.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/scanner.dart';
+import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
  * A computer for calculating `completion.getSuggestions` request results
  * for the local library in which the completion is requested.
  */
 class LocalComputer extends DartCompletionComputer {
 
   @override
   bool computeFast(DartCompletionRequest request) {
     OpType optype = request.optype;
@@ skipping 173 matching lines @@
   final bool excludeVoidReturn;
 
   _LocalVisitor(this.request, int offset, this.typesOnly,
       this.excludeVoidReturn)
       : super(offset);
 
   @override
   void declaredClass(ClassDeclaration declaration) {
     bool isDeprecated = _isDeprecated(declaration);
     CompletionSuggestion suggestion =
-        _addSuggestion(declaration.name, NO_RETURN_TYPE, null, isDeprecated);
+        _addSuggestion(declaration.name, NO_RETURN_TYPE, isDeprecated);
     if (suggestion != null) {
       suggestion.element = _createElement(
           protocol.ElementKind.CLASS,
           declaration.name,
-          null,
-          NO_RETURN_TYPE,
-          declaration.isAbstract,
-          isDeprecated);
+          returnType: NO_RETURN_TYPE,

[Paul Berry, 2015/01/14 17:48:35]

Nit: it seems unfortunate to me that we have to indicate the absence of a return
type so deliberately--it would be nice if simply leaving out the "returnType"
parameter meant "no return type".  But I can't think of a good way to make that
work, since as I understand it we need a returnType of void to be turned into
"dynamic".

[danrubel, 2015/01/15 02:26:27]

I agree and don't like this either but could not find a better way. I'll ponder
it some more and see if I can refactor this in a subsequent CL.

+          isAbstract: declaration.isAbstract,
+          isDeprecated: isDeprecated);
     }
   }
 
   @override
   void declaredClassTypeAlias(ClassTypeAlias declaration) {
     bool isDeprecated = _isDeprecated(declaration);
     CompletionSuggestion suggestion =
-        _addSuggestion(declaration.name, NO_RETURN_TYPE, null, isDeprecated);
+        _addSuggestion(declaration.name, NO_RETURN_TYPE, isDeprecated);
     if (suggestion != null) {
       suggestion.element = _createElement(
           protocol.ElementKind.CLASS_TYPE_ALIAS,
           declaration.name,
-          null,
-          NO_RETURN_TYPE,
-          true,
-          isDeprecated);
+          returnType: NO_RETURN_TYPE,
+          isAbstract: true,
+          isDeprecated: isDeprecated);
     }
   }
 
   @override
   void declaredField(FieldDeclaration fieldDecl, VariableDeclaration varDecl) {
     if (typesOnly) {
       return;
     }
     bool isDeprecated = _isDeprecated(fieldDecl) || _isDeprecated(varDecl);
     TypeName type = fieldDecl.fields.type;
     CompletionSuggestion suggestion =
-        _addSuggestion(varDecl.name, type, fieldDecl.parent, isDeprecated);
+        _addSuggestion(varDecl.name, type, isDeprecated, classDecl: fieldDecl.parent);
     if (suggestion != null) {
       suggestion.element = _createElement(
           protocol.ElementKind.FIELD,
           varDecl.name,
-          null,
-          type,
-          false,
-          isDeprecated);
+          returnType: type,
+          isDeprecated: isDeprecated);
     }
   }
 
   @override
   void declaredFunction(FunctionDeclaration declaration) {
     if (typesOnly) {
       return;
     }
     TypeName returnType = declaration.returnType;
     bool isDeprecated = _isDeprecated(declaration);
     protocol.ElementKind kind;
     if (declaration.isGetter) {
       kind = protocol.ElementKind.GETTER;
     } else if (declaration.isSetter) {
       if (excludeVoidReturn) {
         return;
       }
       kind = protocol.ElementKind.SETTER;
       returnType = NO_RETURN_TYPE;
     } else {
       if (excludeVoidReturn && _isVoid(returnType)) {
         return;
       }
       kind = protocol.ElementKind.FUNCTION;
     }
     CompletionSuggestion suggestion =
-        _addSuggestion(declaration.name, returnType, null, isDeprecated);
+        _addSuggestion(declaration.name, returnType, isDeprecated);
     if (suggestion != null) {
       FormalParameterList param = declaration.functionExpression.parameters;
       suggestion.element = _createElement(
           kind,
           declaration.name,
-          param != null ? param.toSource() : null,
-          returnType,
-          false,
-          isDeprecated);
+          parameters: param != null ? param.toSource() : null,
+          returnType: returnType,
+          isDeprecated: isDeprecated);
+      if (kind == protocol.ElementKind.FUNCTION) {
+        _addParameterInfo(
+            suggestion,
+            declaration.functionExpression.parameters);
+      }
     }
   }
 
   @override
   void declaredFunctionTypeAlias(FunctionTypeAlias declaration) {
     bool isDeprecated = _isDeprecated(declaration);
     TypeName returnType = declaration.returnType;
     CompletionSuggestion suggestion =
-        _addSuggestion(declaration.name, returnType, null, isDeprecated);
+        _addSuggestion(declaration.name, returnType, isDeprecated);
     if (suggestion != null) {
       // TODO (danrubel) determine parameters and return type
       suggestion.element = _createElement(
           protocol.ElementKind.FUNCTION_TYPE_ALIAS,
           declaration.name,
-          null,
-          returnType,
-          true,
-          isDeprecated);
+          returnType: returnType,
+          isAbstract: true,
+          isDeprecated: isDeprecated);
     }
   }
 
   @override
   void declaredLabel(Label label, bool isCaseLabel) {
     // ignored
   }
 
   @override
   void declaredLocalVar(SimpleIdentifier name, TypeName type) {
     if (typesOnly) {
       return;
     }
-    CompletionSuggestion suggestion = _addSuggestion(name, type, null, false);
+    CompletionSuggestion suggestion = _addSuggestion(name, type, false);
     if (suggestion != null) {
-      suggestion.element = _createElement(
-          protocol.ElementKind.LOCAL_VARIABLE,
-          name,
-          null,
-          type,
-          false,
-          false);
+      suggestion.element =
+          _createElement(protocol.ElementKind.LOCAL_VARIABLE, name, returnType: type);
     }
   }
 
   @override
   void declaredMethod(MethodDeclaration declaration) {
     if (typesOnly) {
       return;
     }
     protocol.ElementKind kind;
     String parameters;
     TypeName returnType = declaration.returnType;
     if (declaration.isGetter) {
       kind = protocol.ElementKind.GETTER;
       parameters = null;
     } else if (declaration.isSetter) {
       if (excludeVoidReturn) {
         return;
       }
       kind = protocol.ElementKind.SETTER;
       returnType = NO_RETURN_TYPE;
     } else {
       if (excludeVoidReturn && _isVoid(returnType)) {
         return;
       }
       kind = protocol.ElementKind.METHOD;
       parameters = declaration.parameters.toSource();
     }
     bool isDeprecated = _isDeprecated(declaration);
-    CompletionSuggestion suggestion =
-        _addSuggestion(declaration.name, returnType, declaration.parent, isDeprecated);
+    CompletionSuggestion suggestion = _addSuggestion(
+        declaration.name,
+        returnType,
+        isDeprecated,
+        classDecl: declaration.parent);
     if (suggestion != null) {
       suggestion.element = _createElement(
           kind,
           declaration.name,
-          parameters,
-          returnType,
-          declaration.isAbstract,
-          isDeprecated);
+          parameters: parameters,
+          returnType: returnType,
+          isAbstract: declaration.isAbstract,
+          isDeprecated: isDeprecated);
+      if (kind == protocol.ElementKind.METHOD) {
+        _addParameterInfo(suggestion, declaration.parameters);
+      }
     }
   }
 
   @override
   void declaredParam(SimpleIdentifier name, TypeName type) {
     if (typesOnly) {
       return;
     }
-    CompletionSuggestion suggestion = _addSuggestion(name, type, null, false);
+    CompletionSuggestion suggestion = _addSuggestion(name, type, false);
     if (suggestion != null) {
       suggestion.element =
-          _createElement(protocol.ElementKind.PARAMETER, name, null, type, false, false);
+          _createElement(protocol.ElementKind.PARAMETER, name, returnType: type);
     }
   }
 
   @override
   void declaredTopLevelVar(VariableDeclarationList varList,
       VariableDeclaration varDecl) {
     if (typesOnly) {
       return;
     }
     bool isDeprecated = _isDeprecated(varList) || _isDeprecated(varDecl);
     CompletionSuggestion suggestion =
-        _addSuggestion(varDecl.name, varList.type, null, isDeprecated);
+        _addSuggestion(varDecl.name, varList.type, isDeprecated);
     if (suggestion != null) {
       suggestion.element = _createElement(
           protocol.ElementKind.TOP_LEVEL_VARIABLE,
           varDecl.name,
-          null,
-          varList.type,
-          false,
-          isDeprecated);
+          returnType: varList.type,
+          isDeprecated: isDeprecated);
     }
   }
 
+  void _addParameterInfo(CompletionSuggestion suggestion,
+      FormalParameterList parameters) {
+    var paramList = parameters.parameters;
+    suggestion.parameterNames =
+        paramList.map((FormalParameter param) => param.identifier.name).toList();
+    suggestion.parameterTypes = paramList.map((FormalParameter param) {
+      TypeName type = null;
+      if (param is DefaultFormalParameter) {
+        NormalFormalParameter child = param.parameter;
+        if (child is SimpleFormalParameter) {
+          type = child.type;
+        } else if (child is FieldFormalParameter) {
+          type = child.type;
+        }
+      }
+      if (param is SimpleFormalParameter) {
+        type = param.type;
+      } else if (param is FieldFormalParameter) {
+        type = param.type;
+      }
+      if (type == null) {
+        return 'dynamic';
+      }
+      Identifier typeId = type.name;
+      if (typeId == null) {
+        return 'dynamic';
+      }
+      return typeId.name;
+    }).toList();
+    suggestion.requiredParameterCount = paramList.where(
+        (FormalParameter param) => param is! DefaultFormalParameter).length;
+    suggestion.hasNamedParameters =
+        paramList.any((FormalParameter param) => param.kind == ParameterKind.NAMED);
+  }
+
   CompletionSuggestion _addSuggestion(SimpleIdentifier id, TypeName returnType,
-      ClassDeclaration classDecl, bool isDeprecated) {
+      bool isDeprecated, {ClassDeclaration classDecl}) {
     if (id != null) {
       String completion = id.name;
       if (completion != null && completion.length > 0 && completion != '_') {
         CompletionSuggestion suggestion = new CompletionSuggestion(
             CompletionSuggestionKind.INVOCATION,
             isDeprecated ? COMPLETION_RELEVANCE_LOW : COMPLETION_RELEVANCE_DEFAULT,
             completion,
             completion.length,
             0,
-            false,
+            isDeprecated,
             false,
             returnType: _nameForType(returnType));
         if (classDecl != null) {
           SimpleIdentifier identifier = classDecl.name;
           if (identifier != null) {
             String name = identifier.name;
             if (name != null && name.length > 0) {
               suggestion.declaringType = name;
             }
           }
         }
         request.suggestions.add(suggestion);
         return suggestion;
       }
     }
     return null;
   }
 
 
   /**
    * Create a new protocol Element for inclusion in a completion suggestion.
    */
   protocol.Element _createElement(protocol.ElementKind kind,
-      SimpleIdentifier id, String parameters, TypeName returnType, bool isAbstract,
-      bool isDeprecated) {
+      SimpleIdentifier id, {String parameters, TypeName returnType, bool isAbstract:
+      false, bool isDeprecated: false}) {
     String name = id.name;
     int flags = protocol.Element.makeFlags(
         isAbstract: isAbstract,
         isDeprecated: isDeprecated,
         isPrivate: Identifier.isPrivateName(name));
     return new protocol.Element(
         kind,
         name,
         flags,
         parameters: parameters,
@@ skipping 43 matching lines @@
     if (name == null || name.length <= 0) {
       return DYNAMIC;
     }
     TypeArgumentList typeArgs = type.typeArguments;
     if (typeArgs != null) {
       //TODO (danrubel) include type arguments
     }
     return name;
   }
 }