typescript 5.1.0-dev.20230404 → 5.1.0-dev.20230406

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230404`;
+      version = `${versionMajorMinor}.0-dev.20230406`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -31763,6 +31763,12 @@ ${lanes.join("\n")}
               if (languageVariant === 1 /* JSX */) {
                 return parseJsxElementOrSelfClosingElementOrFragment(
                   /*inExpressionContext*/
+                  true,
+                  /*topInvalidNodePosition*/
+                  void 0,
+                  /*openingTag*/
+                  void 0,
+                  /*mustBeUnary*/
                   true
                 );
               }
@@ -31867,7 +31873,7 @@ ${lanes.join("\n")}
             true
           )), pos);
         }
-        function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext, topInvalidNodePosition, openingTag) {
+        function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext, topInvalidNodePosition, openingTag, mustBeUnary = false) {
           const pos = getNodePos();
           const opening = parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext);
           let result;
@@ -31905,7 +31911,7 @@ ${lanes.join("\n")}
             Debug.assert(opening.kind === 283 /* JsxSelfClosingElement */);
             result = opening;
           }
-          if (inExpressionContext && token() === 29 /* LessThanToken */) {
+          if (!mustBeUnary && inExpressionContext && token() === 29 /* LessThanToken */) {
             const topBadPos = typeof topInvalidNodePosition === "undefined" ? result.pos : topInvalidNodePosition;
             const invalidElement = tryParse(() => parseJsxElementOrSelfClosingElementOrFragment(
               /*inExpressionContext*/
@@ -31938,7 +31944,7 @@ ${lanes.join("\n")}
                 parseErrorAtRange(openingTag, Diagnostics.JSX_fragment_has_no_corresponding_closing_tag);
               } else {
                 const tag = openingTag.tagName;
-                const start = skipTrivia(sourceText, tag.pos);
+                const start = Math.min(skipTrivia(sourceText, tag.pos), tag.end);
                 parseErrorAt(start, tag.end, Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, getTextOfNodeFromSourceText(sourceText, openingTag.tagName));
               }
               return void 0;
@@ -82801,6 +82807,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;
@@ -92334,11 +92348,12 @@ ${lanes.join("\n")}
       return visitEachChild(node, visitor, context);
     }
     function visitArrayAssignmentElement(node) {
-      Debug.assertNode(node, isArrayBindingOrAssignmentElement);
-      if (isSpreadElement(node))
-        return visitAssignmentRestElement(node);
-      if (!isOmittedExpression(node))
-        return visitAssignmentElement(node);
+      if (isArrayBindingOrAssignmentElement(node)) {
+        if (isSpreadElement(node))
+          return visitAssignmentRestElement(node);
+        if (!isOmittedExpression(node))
+          return visitAssignmentElement(node);
+      }
       return visitEachChild(node, visitor, context);
     }
     function visitAssignmentProperty(node) {
@@ -118504,9 +118519,6 @@ ${lanes.join("\n")}
         if (moduleKind === 2 /* AMD */ || moduleKind === 3 /* UMD */ || moduleKind === 4 /* System */) {
           createDiagnosticForOptionName(Diagnostics.Option_verbatimModuleSyntax_cannot_be_used_when_module_is_set_to_UMD_AMD_or_System, "verbatimModuleSyntax");
         }
-        if (options.isolatedModules) {
-          createRedundantOptionDiagnostic("isolatedModules", "verbatimModuleSyntax");
-        }
         if (options.preserveValueImports) {
           createRedundantOptionDiagnostic("preserveValueImports", "verbatimModuleSyntax");
         }
@@ -121203,7 +121215,7 @@ ${lanes.join("\n")}
         return {
           dir: rootDir,
           dirPath: rootPath,
-          nonRecursive: false
+          nonRecursive: true
         };
       }
     }
@@ -121651,7 +121663,7 @@ ${lanes.join("\n")}
               customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1);
             }
             if (dirPath === rootPath) {
-              Debug.assert(!nonRecursive);
+              Debug.assert(nonRecursive);
               setAtRoot = true;
             } else {
               setDirectoryWatcher(dir, dirPath, nonRecursive);
@@ -148111,6 +148123,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 +148164,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 +148276,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),