fixed signature providers

DonJayamanne · DonJayamanne · commit 963325cb348b · 2016-11-04T09:16:12.000+11:00
diff --git a/pythonFiles/completion.py b/pythonFiles/completion.py
@@ -56,11 +56,11 @@ def _get_top_level_module(cls, path):
     def _generate_signature(self, completion):
         """Generate signature with function arguments.
         """
-        if not hasattr(completion, 'params'):
+        if completion.type in ['module'] or not hasattr(completion, 'params'):
             return ''
         return '%s(%s)' % (
             completion.name,
-            ', '.join(param.description for param in completion.params))
+            ', '.join(p.description for p in completion.params if p))
 
     def _get_call_signatures(self, script):
         """Extract call signatures from jedi.api.Script object in failsafe way.
@@ -195,6 +195,38 @@ def _serialize_completions(self, script, identifier=None, prefix=''):
             _completions.append(_completion)
         return json.dumps({'id': identifier, 'results': _completions})
 
+    def _serialize_methods(self, script, identifier=None, prefix=''):
+        _methods = []
+        try:
+            completions = script.completions()
+        except KeyError:
+            return []
+
+        for completion in completions:
+            if completion.name == '__autocomplete_python':
+              instance = completion.parent().name
+              break
+        else:
+            instance = 'self.__class__'
+
+        for completion in completions:
+            params = []
+            if hasattr(completion, 'params'):
+                params = [p.description for p in completion.params
+                          if ARGUMENT_RE.match(p.description)]
+            if completion.parent().type == 'class':
+              _methods.append({
+                'parent': completion.parent().name,
+                'instance': instance,
+                'name': completion.name,
+                'params': params,
+                'moduleName': completion.module_name,
+                'fileName': completion.module_path,
+                'line': completion.line,
+                'column': completion.column,
+              })
+        return json.dumps({'id': identifier, 'results': _methods})
+
     def _serialize_arguments(self, script, identifier=None):
         """Serialize response to be read from VSCode.
 
@@ -207,6 +239,16 @@ def _serialize_arguments(self, script, identifier=None):
         """
         return json.dumps({"id": identifier, "results": self._get_call_signatures_with_args(script)})
 
+    def _top_definition(self, definition):
+        for d in definition.goto_assignments():
+            if d == definition:
+                continue
+            if d.type == 'import':
+                return self._top_definition(d)
+            else:
+                return d
+        return definition
+
     def _serialize_definitions(self, definitions, identifier=None):
         """Serialize response to be read from VSCode.
 
@@ -217,24 +259,14 @@ def _serialize_definitions(self, definitions, identifier=None):
         Returns:
             Serialized string to send to VSCode.
         """
-
-        def _top_definition(definition):
-            for d in definition.goto_assignments():
-                if d == definition:
-                    continue
-                if d.type == 'import':
-                    return _top_definition(d)
-                else:
-                    return d
-            return definition
-
         _definitions = []
         for definition in definitions:
             try:
                 if definition.module_path:
                     if definition.type == 'import':
-                        definition = _top_definition(definition)
-
+                        definition = self._top_definition(definition)
+                    if not definition.module_path:
+                        continue
                     _definition = {
                         'text': definition.name,
                         'type': self._get_definition_type(definition),
@@ -248,6 +280,32 @@ def _top_definition(definition):
                 pass
         return json.dumps({'id': identifier, 'results': _definitions})
 
+    def _serialize_tooltip(self, definitions, identifier=None):
+        _definitions = []
+        for definition in definitions:
+            if definition.module_path:
+                if definition.type == 'import':
+                    definition = self._top_definition(definition)
+                if not definition.module_path:
+                  continue
+
+                description = definition.docstring()
+                if description is not None:
+                  description = description.strip()
+                if not description:
+                  description = self._additional_info(definition)
+                _definition = {
+                    'text': definition.name,
+                    'type': self._get_definition_type(definition),
+                    'fileName': definition.module_path,
+                    'description': description,
+                    'line': definition.line - 1,
+                    'column': definition.column
+                }
+                _definitions.append(_definition)
+                break
+        return json.dumps({'id': identifier, 'results': _definitions})
+
     def _serialize_usages(self, usages, identifier=None):
         _usages = []
         for usage in usages:
@@ -318,12 +376,19 @@ def _process_request(self, request):
         if lookup == 'definitions':
             return self._write_response(self._serialize_definitions(
                 script.goto_assignments(), request['id']))
+        if lookup == 'tooltip':
+            return self._write_response(self._serialize_tooltip(
+                script.goto_assignments(), request['id']))
         elif lookup == 'arguments':
             return self._write_response(self._serialize_arguments(
                 script, request['id']))
         elif lookup == 'usages':
             return self._write_response(self._serialize_usages(
                 script.usages(), request['id']))
+        elif lookup == 'methods':
+          return self._write_response(
+              self._serialize_methods(script, request['id'],
+                                      request.get('prefix', '')))
         else:
             return self._write_response(
                 self._serialize_completions(script, request['id'],
diff --git a/src/client/providers/signatureProvider.ts b/src/client/providers/signatureProvider.ts
@@ -80,18 +80,16 @@ export class PythonSignatureProvider implements vscode.SignatureHelpProvider {
         return new SignatureHelp();
     }
     provideSignatureHelp(document: TextDocument, position: Position, token: CancellationToken): Thenable<SignatureHelp> {
-        return new Promise<SignatureHelp>((resolve, reject) => {
-            let cmd: proxy.ICommand<proxy.IArgumentsResult> = {
-                telemetryEvent: telemetryContracts.IDE.Symbol,
-                command: proxy.CommandType.Arguments,
-                fileName: document.fileName,
-                columnIndex: position.character,
-                lineIndex: position.line,
-                source: document.getText()
-            };
-            return this.jediProxyHandler.sendCommand(cmd, token).then(data => {
-                return PythonSignatureProvider.parseData(data);
-            });
+        let cmd: proxy.ICommand<proxy.IArgumentsResult> = {
+            telemetryEvent: telemetryContracts.IDE.Symbol,
+            command: proxy.CommandType.Arguments,
+            fileName: document.fileName,
+            columnIndex: position.character,
+            lineIndex: position.line,
+            source: document.getText()
+        };
+        return this.jediProxyHandler.sendCommand(cmd, token).then(data => {
+            return PythonSignatureProvider.parseData(data);
         });
     }
 }
