typescript 5.1.0-dev.20230403 → 5.1.0-dev.20230405

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230403`;
+      version = `${versionMajorMinor}.0-dev.20230405`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -82801,6 +82801,14 @@ ${lanes.join("\n")}
         const symbol = getSymbolAtLocation(node);
         return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType;
       }
+      if (isBindingElement(node)) {
+        return getTypeForVariableLikeDeclaration(
+          node,
+          /*includeOptionality*/
+          true,
+          0 /* Normal */
+        ) || errorType;
+      }
       if (isDeclaration(node)) {
         const symbol = getSymbolOfDeclaration(node);
         return symbol ? getTypeOfSymbol(symbol) : errorType;
@@ -148111,6 +148119,7 @@ ${lanes.join("\n")}
       return void 0;
     }
     const compilerOptions = program.getCompilerOptions();
+    const checker = program.getTypeChecker();
     const incompleteCompletionsCache = preferences.allowIncompleteCompletions ? (_a2 = host.getIncompleteCompletionsCache) == null ? void 0 : _a2.call(host) : void 0;
     if (incompleteCompletionsCache && completionKind === 3 /* TriggerForIncompleteCompletions */ && previousToken && isIdentifier(previousToken)) {
       const incompleteContinuation = continuePreviousIncompleteResponse(incompleteCompletionsCache, sourceFile, previousToken, program, host, preferences, cancellationToken, position);
@@ -148151,9 +148160,31 @@ ${lanes.join("\n")}
         }
         return response;
       case 1 /* JsDocTagName */:
-        return jsdocCompletionInfo(ts_JsDoc_exports.getJSDocTagNameCompletions());
+        return jsdocCompletionInfo([
+          ...ts_JsDoc_exports.getJSDocTagNameCompletions(),
+          ...getJSDocParameterCompletions(
+            sourceFile,
+            position,
+            checker,
+            compilerOptions,
+            preferences,
+            /*tagNameOnly*/
+            true
+          )
+        ]);
       case 2 /* JsDocTag */:
-        return jsdocCompletionInfo(ts_JsDoc_exports.getJSDocTagCompletions());
+        return jsdocCompletionInfo([
+          ...ts_JsDoc_exports.getJSDocTagCompletions(),
+          ...getJSDocParameterCompletions(
+            sourceFile,
+            position,
+            checker,
+            compilerOptions,
+            preferences,
+            /*tagNameOnly*/
+            false
+          )
+        ]);
       case 3 /* JsDocParameterName */:
         return jsdocCompletionInfo(ts_JsDoc_exports.getJSDocParameterNameCompletions(completionData.tag));
       case 4 /* Keywords */:
@@ -148241,6 +148272,264 @@ ${lanes.join("\n")}
   function jsdocCompletionInfo(entries) {
     return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries };
   }
+  function getJSDocParameterCompletions(sourceFile, position, checker, options, preferences, tagNameOnly) {
+    const currentToken = getTokenAtPosition(sourceFile, position);
+    if (!isJSDocTag(currentToken) && !isJSDoc(currentToken)) {
+      return [];
+    }
+    const jsDoc = isJSDoc(currentToken) ? currentToken : currentToken.parent;
+    if (!isJSDoc(jsDoc)) {
+      return [];
+    }
+    const func = jsDoc.parent;
+    if (!isFunctionLike(func)) {
+      return [];
+    }
+    const isJs = isSourceFileJS(sourceFile);
+    const isSnippet = preferences.includeCompletionsWithSnippetText || void 0;
+    const paramTagCount = countWhere(jsDoc.tags, (tag) => isJSDocParameterTag(tag) && tag.getEnd() <= position);
+    return mapDefined(func.parameters, (param) => {
+      if (getJSDocParameterTags(param).length) {
+        return void 0;
+      }
+      if (isIdentifier(param.name)) {
+        const tabstopCounter = { tabstop: 1 };
+        const paramName = param.name.text;
+        let displayText = getJSDocParamAnnotation(
+          paramName,
+          param.initializer,
+          param.dotDotDotToken,
+          isJs,
+          /*isObject*/
+          false,
+          /*isSnippet*/
+          false,
+          checker,
+          options,
+          preferences
+        );
+        let snippetText = isSnippet ? getJSDocParamAnnotation(
+          paramName,
+          param.initializer,
+          param.dotDotDotToken,
+          isJs,
+          /*isObject*/
+          false,
+          /*isSnippet*/
+          true,
+          checker,
+          options,
+          preferences,
+          tabstopCounter
+        ) : void 0;
+        if (tagNameOnly) {
+          displayText = displayText.slice(1);
+          if (snippetText)
+            snippetText = snippetText.slice(1);
+        }
+        return {
+          name: displayText,
+          kind: "parameter" /* parameterElement */,
+          sortText: SortText.LocationPriority,
+          insertText: isSnippet ? snippetText : void 0,
+          isSnippet
+        };
+      } else if (param.parent.parameters.indexOf(param) === paramTagCount) {
+        const paramPath = `param${paramTagCount}`;
+        const displayTextResult = generateJSDocParamTagsForDestructuring(
+          paramPath,
+          param.name,
+          param.initializer,
+          param.dotDotDotToken,
+          isJs,
+          /*isSnippet*/
+          false,
+          checker,
+          options,
+          preferences
+        );
+        const snippetTextResult = isSnippet ? generateJSDocParamTagsForDestructuring(
+          paramPath,
+          param.name,
+          param.initializer,
+          param.dotDotDotToken,
+          isJs,
+          /*isSnippet*/
+          true,
+          checker,
+          options,
+          preferences
+        ) : void 0;
+        let displayText = displayTextResult.join(getNewLineCharacter(options) + "* ");
+        let snippetText = snippetTextResult == null ? void 0 : snippetTextResult.join(getNewLineCharacter(options) + "* ");
+        if (tagNameOnly) {
+          displayText = displayText.slice(1);
+          if (snippetText)
+            snippetText = snippetText.slice(1);
+        }
+        return {
+          name: displayText,
+          kind: "parameter" /* parameterElement */,
+          sortText: SortText.LocationPriority,
+          insertText: isSnippet ? snippetText : void 0,
+          isSnippet
+        };
+      }
+    });
+  }
+  function generateJSDocParamTagsForDestructuring(path, pattern, initializer, dotDotDotToken, isJs, isSnippet, checker, options, preferences) {
+    if (!isJs) {
+      return [
+        getJSDocParamAnnotation(
+          path,
+          initializer,
+          dotDotDotToken,
+          isJs,
+          /*isObject*/
+          false,
+          isSnippet,
+          checker,
+          options,
+          preferences,
+          { tabstop: 1 }
+        )
+      ];
+    }
+    return patternWorker(path, pattern, initializer, dotDotDotToken, { tabstop: 1 });
+    function patternWorker(path2, pattern2, initializer2, dotDotDotToken2, counter) {
+      if (isObjectBindingPattern(pattern2) && !dotDotDotToken2) {
+        const oldTabstop = counter.tabstop;
+        const childCounter = { tabstop: oldTabstop };
+        const rootParam = getJSDocParamAnnotation(
+          path2,
+          initializer2,
+          dotDotDotToken2,
+          isJs,
+          /*isObject*/
+          true,
+          isSnippet,
+          checker,
+          options,
+          preferences,
+          childCounter
+        );
+        let childTags = [];
+        for (const element of pattern2.elements) {
+          const elementTags = elementWorker(path2, element, childCounter);
+          if (!elementTags) {
+            childTags = void 0;
+            break;
+          } else {
+            childTags.push(...elementTags);
+          }
+        }
+        if (childTags) {
+          counter.tabstop = childCounter.tabstop;
+          return [rootParam, ...childTags];
+        }
+      }
+      return [
+        getJSDocParamAnnotation(
+          path2,
+          initializer2,
+          dotDotDotToken2,
+          isJs,
+          /*isObject*/
+          false,
+          isSnippet,
+          checker,
+          options,
+          preferences,
+          counter
+        )
+      ];
+    }
+    function elementWorker(path2, element, counter) {
+      if (!element.propertyName && isIdentifier(element.name) || isIdentifier(element.name)) {
+        const propertyName = element.propertyName ? tryGetTextOfPropertyName(element.propertyName) : element.name.text;
+        if (!propertyName) {
+          return void 0;
+        }
+        const paramName = `${path2}.${propertyName}`;
+        return [
+          getJSDocParamAnnotation(
+            paramName,
+            element.initializer,
+            element.dotDotDotToken,
+            isJs,
+            /*isObject*/
+            false,
+            isSnippet,
+            checker,
+            options,
+            preferences,
+            counter
+          )
+        ];
+      } else if (element.propertyName) {
+        const propertyName = tryGetTextOfPropertyName(element.propertyName);
+        return propertyName && patternWorker(`${path2}.${propertyName}`, element.name, element.initializer, element.dotDotDotToken, counter);
+      }
+      return void 0;
+    }
+  }
+  function getJSDocParamAnnotation(paramName, initializer, dotDotDotToken, isJs, isObject, isSnippet, checker, options, preferences, tabstopCounter) {
+    if (isSnippet) {
+      Debug.assertIsDefined(tabstopCounter);
+    }
+    if (initializer) {
+      paramName = getJSDocParamNameWithInitializer(paramName, initializer);
+    }
+    if (isSnippet) {
+      paramName = escapeSnippetText(paramName);
+    }
+    if (isJs) {
+      let type = "*";
+      if (isObject) {
+        Debug.assert(!dotDotDotToken, `Cannot annotate a rest parameter with type 'Object'.`);
+        type = "Object";
+      } else {
+        if (initializer) {
+          const inferredType = checker.getTypeAtLocation(initializer.parent);
+          if (!(inferredType.flags & (1 /* Any */ | 16384 /* Void */))) {
+            const sourceFile = initializer.getSourceFile();
+            const quotePreference = getQuotePreference(sourceFile, preferences);
+            const builderFlags = quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */;
+            const typeNode = checker.typeToTypeNode(inferredType, findAncestor(initializer, isFunctionLike), builderFlags);
+            if (typeNode) {
+              const printer = isSnippet ? createSnippetPrinter({
+                removeComments: true,
+                module: options.module,
+                target: options.target
+              }) : createPrinter({
+                removeComments: true,
+                module: options.module,
+                target: options.target
+              });
+              setEmitFlags(typeNode, 1 /* SingleLine */);
+              type = printer.printNode(4 /* Unspecified */, typeNode, sourceFile);
+            }
+          }
+        }
+        if (isSnippet && type === "*") {
+          type = `\${${tabstopCounter.tabstop++}:${type}}`;
+        }
+      }
+      const dotDotDot = !isObject && dotDotDotToken ? "..." : "";
+      const description2 = isSnippet ? `\${${tabstopCounter.tabstop++}}` : "";
+      return `@param {${dotDotDot}${type}} ${paramName} ${description2}`;
+    } else {
+      const description2 = isSnippet ? `\${${tabstopCounter.tabstop++}}` : "";
+      return `@param ${paramName} ${description2}`;
+    }
+  }
+  function getJSDocParamNameWithInitializer(paramName, initializer) {
+    const initializerText = initializer.getText().trim();
+    if (initializerText.includes("\n") || initializerText.length > 80) {
+      return `[${paramName}]`;
+    }
+    return `[${paramName}=${initializerText}]`;
+  }
   function keywordToCompletionEntry(keyword) {
     return {
       name: tokenToString(keyword),
@@ -153387,7 +153676,7 @@ ${lanes.join("\n")}
       ((Core2) => {
         function getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options = {}, sourceFilesSet = new Set(sourceFiles.map((f) => f.fileName))) {
           var _a2, _b, _c;
-          node = getAdjustedNode(node, options);
+          node = getAdjustedNode2(node, options);
           if (isSourceFile(node)) {
             const resolvedRef = ts_GoToDefinition_exports.getReferenceAtPosition(node, position, program);
             if (!(resolvedRef == null ? void 0 : resolvedRef.file)) {
@@ -153455,7 +153744,7 @@ ${lanes.join("\n")}
           return mergeReferences(program, moduleReferences, references, moduleReferencesOfExportTarget);
         }
         Core2.getReferencedSymbolsForNode = getReferencedSymbolsForNode;
-        function getAdjustedNode(node, options) {
+        function getAdjustedNode2(node, options) {
           if (options.use === 1 /* References */) {
             node = getAdjustedReferenceLocation(node);
           } else if (options.use === 2 /* Rename */) {
@@ -153463,7 +153752,7 @@ ${lanes.join("\n")}
           }
           return node;
         }
-        Core2.getAdjustedNode = getAdjustedNode;
+        Core2.getAdjustedNode = getAdjustedNode2;
         function getReferencesForFileName(fileName, program, sourceFiles, sourceFilesSet = new Set(sourceFiles.map((f) => f.fileName))) {
           var _a2, _b;
           const moduleSymbol = (_a2 = program.getSourceFile(fileName)) == null ? void 0 : _a2.symbol;
@@ -162566,8 +162855,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     return isBinaryExpression(b.left) ? countBinaryExpressionParameters(b.left) + 1 : 2;
   }
   function tryGetParameterInfo(startingToken, position, sourceFile, checker) {
-    const info = getContextualSignatureLocationInfo(startingToken, sourceFile, position, checker);
-    if (!info)
+    const node = getAdjustedNode(startingToken);
+    if (node === void 0)
+      return void 0;
+    const info = getContextualSignatureLocationInfo(node, sourceFile, position, checker);
+    if (info === void 0)
       return void 0;
     const { contextualType, argumentIndex, argumentCount, argumentsSpan } = info;
     const nonNullableContextualType = contextualType.getNonNullableType();
@@ -162580,16 +162872,23 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     const invocation = { kind: 2 /* Contextual */, signature, node: startingToken, symbol: chooseBetterSymbol(symbol) };
     return { isTypeParameterList: false, invocation, argumentsSpan, argumentIndex, argumentCount };
   }
-  function getContextualSignatureLocationInfo(startingToken, sourceFile, position, checker) {
-    if (startingToken.kind !== 20 /* OpenParenToken */ && startingToken.kind !== 27 /* CommaToken */)
-      return void 0;
-    const { parent: parent2 } = startingToken;
+  function getAdjustedNode(node) {
+    switch (node.kind) {
+      case 20 /* OpenParenToken */:
+      case 27 /* CommaToken */:
+        return node;
+      default:
+        return findAncestor(node.parent, (n) => isParameter(n) ? true : isBindingElement(n) || isObjectBindingPattern(n) || isArrayBindingPattern(n) ? false : "quit");
+    }
+  }
+  function getContextualSignatureLocationInfo(node, sourceFile, position, checker) {
+    const { parent: parent2 } = node;
     switch (parent2.kind) {
       case 215 /* ParenthesizedExpression */:
       case 172 /* MethodDeclaration */:
       case 216 /* FunctionExpression */:
       case 217 /* ArrowFunction */:
-        const info = getArgumentOrParameterListInfo(startingToken, position, sourceFile);
+        const info = getArgumentOrParameterListInfo(node, position, sourceFile);
         if (!info)
           return void 0;
         const { argumentIndex, argumentCount, argumentsSpan } = info;
@@ -162598,7 +162897,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       case 224 /* BinaryExpression */: {
         const highestBinary = getHighestBinary(parent2);
         const contextualType2 = checker.getContextualType(highestBinary);
-        const argumentIndex2 = startingToken.kind === 20 /* OpenParenToken */ ? 0 : countBinaryExpressionParameters(parent2) - 1;
+        const argumentIndex2 = node.kind === 20 /* OpenParenToken */ ? 0 : countBinaryExpressionParameters(parent2) - 1;
         const argumentCount2 = countBinaryExpressionParameters(highestBinary);
         return contextualType2 && { contextualType: contextualType2, argumentIndex: argumentIndex2, argumentCount: argumentCount2, argumentsSpan: createTextSpanFromNode(parent2) };
       }