fix(lsp): show the function name in parameter hints, fix unbalanced "(("

The LSP parameter-hint popup rendered "((tableName: any)" - a doubled, unbalanced
paren and no function name. requestParameterHints dropped the signature label and
activeSignature, so the provider couldn't supply the function name; the manager
then fell back to editor.getToken() at the caret, which is the just-typed "(".

- LSPClient: pass the full signature label and activeSignature through.
- DefaultProviders: use the active signature (not all overloads merged into one
  param list) and derive the function name from its label.
- ParameterHintsManager: use the provider-supplied functionName when present,
  falling back to the editor token only when absent (preserves Tern behavior).

Now renders e.g. "getTableIndexes(tableName: any)" - named and balanced.

Author: abose

src/features/ParameterHintsManager.js

@@ -269,8 +269,16 @@ define(function (require, exports, module) {
         }
 
         if (hints.parameters.length > 0) {
-            let token = editor.getToken(hints.functionCallPos);
-            _formatParameterHint(token.string, hints.parameters, appendSeparators, appendParameter);
+            // Prefer a function name supplied by the provider (LSP signatureHelp gives the full
+            // signature label). Only fall back to the editor token for providers that locate the call
+            // site themselves (Tern sets functionCallPos); without that fallback guard, an LSP hint -
+            // whose functionCallPos is undefined - would read the token at the caret, i.e. the just
+            // typed "(", and render an unbalanced "((".
+            let functionName = hints.functionName;
+            if (functionName == null) {
+                functionName = editor.getToken(hints.functionCallPos).string;
+            }
+            _formatParameterHint(functionName, hints.parameters, appendSeparators, appendParameter);
         } else {
             $hintContent.append(_.escape(Strings.NO_ARGUMENTS));
         }

src/languageTools/DefaultProviders.js

@@ -630,28 +630,35 @@ define(function (require, exports, module) {
             cursorPos: pos
         }).done(function (msgObj) {
             let paramList = [];
-            let label;
-            let activeParameter;
             if (msgObj) {
-                let res;
-                res = msgObj.signatures;
-                activeParameter = msgObj.activeParameter;
+                let res = msgObj.signatures;
+                let activeParameter = msgObj.activeParameter;
                 if (res && res.length) {
-                    res.forEach(function (element) {
-                        label = element.documentation;
-                        let param = element.parameters;
-                        param.forEach(ele => {
-                            paramList.push({
-                                label: ele.label,
-                                documentation: ele.documentation
-                            });
+                    // Use the active signature (not all of them concatenated - overloads would
+                    // otherwise merge their parameters into one bogus list).
+                    let sig = res[msgObj.activeSignature || 0] || res[0];
+                    (sig.parameters || []).forEach(function (ele) {
+                        paramList.push({
+                            label: ele.label,
+                            documentation: ele.documentation
                         });
                     });
 
+                    // The function name for the popup header, taken from the signature label
+                    // (everything before the parameter list "("). Without this the manager falls back
+                    // to the editor token at the caret - which is the just-typed "(" - producing an
+                    // unbalanced "((tableName: any)".
+                    let functionName = "";
+                    if (typeof sig.label === "string") {
+                        let paren = sig.label.indexOf("(");
+                        functionName = (paren >= 0 ? sig.label.slice(0, paren) : sig.label).trim();
+                    }
+
                     $deferredHints.resolve({
                         parameters: paramList,
                         currentIndex: activeParameter,
-                        functionDocumentation: label
+                        functionDocumentation: sig.documentation,
+                        functionName: functionName
                     });
                 } else {
                     $deferredHints.reject();

src/languageTools/LSPClient.js

@@ -364,6 +364,9 @@ define(function (require, exports, module) {
                 }
                 const signatures = result.signatures.map(function (sig) {
                     return {
+                        // Full signature string (e.g. "getTableIndexes(tableName: any): Promise<…>") -
+                        // the provider derives the function name from it for the parameter-hint popup.
+                        label: sig.label,
                         documentation: _markupToString(sig.documentation) || sig.label,
                         parameters: (sig.parameters || []).map(function (p) {
                             return {
@@ -373,7 +376,11 @@ define(function (require, exports, module) {
                         })
                     };
                 });
-                deferred.resolve({ signatures: signatures, activeParameter: result.activeParameter });
+                deferred.resolve({
+                    signatures: signatures,
+                    activeSignature: result.activeSignature,
+                    activeParameter: result.activeParameter
+                });
             } catch (err) {
                 console.warn("[LSP] request failed:", err && (err.message || err));
                 deferred.reject(err);