typescript 5.1.0-dev.20230427 → 5.1.0-dev.20230429

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230427`;
+      version = `${versionMajorMinor}.0-dev.20230429`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -15388,6 +15388,7 @@ ${lanes.join("\n")}
       case 171 /* PropertyDeclaration */:
       case 170 /* PropertySignature */:
       case 252 /* ReturnStatement */:
+      case 239 /* SemicolonClassElement */:
       case 177 /* SetAccessor */:
       case 303 /* ShorthandPropertyAssignment */:
       case 304 /* SpreadAssignment */:
@@ -33583,11 +33584,11 @@ ${lanes.join("\n")}
         }
         function parseClassElement() {
           const pos = getNodePos();
+          const hasJSDoc = hasPrecedingJSDocComment();
           if (token() === 27 /* SemicolonToken */) {
             nextToken();
-            return finishNode(factory2.createSemicolonClassElement(), pos);
+            return withJSDoc(finishNode(factory2.createSemicolonClassElement(), pos), hasJSDoc);
           }
-          const hasJSDoc = hasPrecedingJSDocComment();
           const modifiers = parseModifiers(
             /*allowDecorators*/
             true,
@@ -46083,13 +46084,14 @@ ${lanes.join("\n")}
       return diagnostic;
     }
     function isDeprecatedSymbol(symbol) {
-      if (length(symbol.declarations) > 1) {
-        const parentSymbol = getParentOfSymbol(symbol);
-        if (parentSymbol && parentSymbol.flags & 64 /* Interface */) {
-          return some(symbol.declarations, (d) => !!(getCombinedNodeFlags(d) & 268435456 /* Deprecated */));
-        }
+      const parentSymbol = getParentOfSymbol(symbol);
+      if (parentSymbol && length(symbol.declarations) > 1) {
+        return parentSymbol.flags & 64 /* Interface */ ? some(symbol.declarations, isDeprecatedDeclaration2) : every(symbol.declarations, isDeprecatedDeclaration2);
       }
-      return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 268435456 /* Deprecated */);
+      return !!symbol.valueDeclaration && isDeprecatedDeclaration2(symbol.valueDeclaration) || length(symbol.declarations) && every(symbol.declarations, isDeprecatedDeclaration2);
+    }
+    function isDeprecatedDeclaration2(declaration) {
+      return !!(getCombinedNodeFlags(declaration) & 268435456 /* Deprecated */);
     }
     function addDeprecatedSuggestion(location, declarations, deprecatedEntity) {
       const diagnostic = createDiagnosticForNode(location, Diagnostics._0_is_deprecated, deprecatedEntity);
@@ -68249,7 +68251,7 @@ ${lanes.join("\n")}
         markAliasReferenced(symbol, node);
       }
       const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
-      const targetSymbol = checkDeprecatedAliasedSymbol(localOrExportSymbol, node);
+      const targetSymbol = resolveAliasWithDeprecationCheck(localOrExportSymbol, node);
       if (isDeprecatedSymbol(targetSymbol) && isUncalledFunctionReference(node, targetSymbol) && targetSymbol.declarations) {
         addDeprecatedSuggestion(node, targetSymbol.declarations, node.escapedText);
       }
@@ -71253,8 +71255,9 @@ ${lanes.join("\n")}
           addDeprecatedSuggestion(right, [indexInfo.declaration], right.escapedText);
         }
       } else {
-        if (isDeprecatedSymbol(prop) && isUncalledFunctionReference(node, prop) && prop.declarations) {
-          addDeprecatedSuggestion(right, prop.declarations, right.escapedText);
+        const targetPropSymbol = resolveAliasWithDeprecationCheck(prop, right);
+        if (isDeprecatedSymbol(targetPropSymbol) && isUncalledFunctionReference(node, targetPropSymbol) && targetPropSymbol.declarations) {
+          addDeprecatedSuggestion(right, targetPropSymbol.declarations, right.escapedText);
         }
         checkPropertyNotUsedBeforeDeclaration(prop, node, right);
         markPropertyAsReferenced(prop, node, isSelfTypeAccess(left, parentSymbol));
@@ -81530,19 +81533,17 @@ ${lanes.join("\n")}
           }
         }
         if (isImportSpecifier(node)) {
-          const targetSymbol = checkDeprecatedAliasedSymbol(symbol, node);
-          if (isDeprecatedAliasedSymbol(targetSymbol) && targetSymbol.declarations) {
+          const targetSymbol = resolveAliasWithDeprecationCheck(symbol, node);
+          if (isDeprecatedSymbol(targetSymbol) && targetSymbol.declarations) {
             addDeprecatedSuggestion(node, targetSymbol.declarations, targetSymbol.escapedName);
           }
         }
       }
     }
-    function isDeprecatedAliasedSymbol(symbol) {
-      return !!symbol.declarations && every(symbol.declarations, (d) => !!(getCombinedNodeFlags(d) & 268435456 /* Deprecated */));
-    }
-    function checkDeprecatedAliasedSymbol(symbol, location) {
-      if (!(symbol.flags & 2097152 /* Alias */))
+    function resolveAliasWithDeprecationCheck(symbol, location) {
+      if (!(symbol.flags & 2097152 /* Alias */) || isDeprecatedSymbol(symbol) || !getDeclarationOfAliasSymbol(symbol)) {
         return symbol;
+      }
       const targetSymbol = resolveAlias(symbol);
       if (targetSymbol === unknownSymbol)
         return targetSymbol;
@@ -81552,7 +81553,7 @@ ${lanes.join("\n")}
           if (target === targetSymbol)
             break;
           if (target.declarations && length(target.declarations)) {
-            if (isDeprecatedAliasedSymbol(target)) {
+            if (isDeprecatedSymbol(target)) {
               addDeprecatedSuggestion(location, target.declarations, target.escapedName);
               break;
             } else {
@@ -93213,6 +93214,19 @@ ${lanes.join("\n")}
       let members = visitNodes2(node.members, visitor, isClassElement);
       let decorationStatements = [];
       ({ members, decorationStatements } = transformDecoratorsOfClassElements(node, members));
+      const assignClassAliasInStaticBlock = languageVersion >= 9 /* ES2022 */ && !!classAlias && some(members, (member) => isPropertyDeclaration(member) && hasSyntacticModifier(member, 32 /* Static */) || isClassStaticBlockDeclaration(member));
+      if (assignClassAliasInStaticBlock) {
+        members = setTextRange(factory2.createNodeArray([
+          factory2.createClassStaticBlockDeclaration(
+            factory2.createBlock([
+              factory2.createExpressionStatement(
+                factory2.createAssignment(classAlias, factory2.createThis())
+              )
+            ])
+          ),
+          ...members
+        ]), members);
+      }
       const classExpression = factory2.createClassExpression(
         modifiers,
         name && isGeneratedIdentifier(name) ? void 0 : name,
@@ -93229,7 +93243,7 @@ ${lanes.join("\n")}
         void 0,
         /*type*/
         void 0,
-        classAlias ? factory2.createAssignment(classAlias, classExpression) : classExpression
+        classAlias && !assignClassAliasInStaticBlock ? factory2.createAssignment(classAlias, classExpression) : classExpression
       );
       setOriginalNode(varDecl, node);
       let varModifiers;
@@ -104291,12 +104305,56 @@ ${lanes.join("\n")}
           return visitExportDeclaration(node);
         case 276 /* ExportAssignment */:
           return visitExportAssignment(node);
+        case 261 /* FunctionDeclaration */:
+          return visitFunctionDeclaration(node);
+        case 262 /* ClassDeclaration */:
+          return visitClassDeclaration(node);
+        default:
+          return topLevelNestedVisitor(node);
+      }
+    }
+    function topLevelNestedVisitor(node) {
+      switch (node.kind) {
         case 242 /* VariableStatement */:
           return visitVariableStatement(node);
         case 261 /* FunctionDeclaration */:
           return visitFunctionDeclaration(node);
         case 262 /* ClassDeclaration */:
           return visitClassDeclaration(node);
+        case 247 /* ForStatement */:
+          return visitForStatement(
+            node,
+            /*isTopLevel*/
+            true
+          );
+        case 248 /* ForInStatement */:
+          return visitForInStatement(node);
+        case 249 /* ForOfStatement */:
+          return visitForOfStatement(node);
+        case 245 /* DoStatement */:
+          return visitDoStatement(node);
+        case 246 /* WhileStatement */:
+          return visitWhileStatement(node);
+        case 255 /* LabeledStatement */:
+          return visitLabeledStatement(node);
+        case 253 /* WithStatement */:
+          return visitWithStatement(node);
+        case 244 /* IfStatement */:
+          return visitIfStatement(node);
+        case 254 /* SwitchStatement */:
+          return visitSwitchStatement(node);
+        case 268 /* CaseBlock */:
+          return visitCaseBlock(node);
+        case 295 /* CaseClause */:
+          return visitCaseClause(node);
+        case 296 /* DefaultClause */:
+          return visitDefaultClause(node);
+        case 257 /* TryStatement */:
+          return visitTryStatement(node);
+        case 298 /* CatchClause */:
+          return visitCatchClause(node);
+        case 240 /* Block */:
+          return visitBlock(node);
         default:
           return visitor(node);
       }
@@ -104307,7 +104365,11 @@ ${lanes.join("\n")}
       }
       switch (node.kind) {
         case 247 /* ForStatement */:
-          return visitForStatement(node);
+          return visitForStatement(
+            node,
+            /*isTopLevel*/
+            false
+          );
         case 243 /* ExpressionStatement */:
           return visitExpressionStatement(node);
         case 216 /* ParenthesizedExpression */:
@@ -104392,15 +104454,177 @@ ${lanes.join("\n")}
       }
       return visitEachChild(node, visitor, context);
     }
-    function visitForStatement(node) {
+    function visitForStatement(node, isTopLevel) {
+      if (isTopLevel && node.initializer && isVariableDeclarationList(node.initializer) && !(node.initializer.flags & 3 /* BlockScoped */)) {
+        const exportStatements = appendExportsOfVariableDeclarationList(
+          /*statements*/
+          void 0,
+          node.initializer,
+          /*isForInOrOfInitializer*/
+          false
+        );
+        if (exportStatements) {
+          const statements = [];
+          const varDeclList = visitNode(node.initializer, discardedValueVisitor, isVariableDeclarationList);
+          const varStatement = factory2.createVariableStatement(
+            /*modifiers*/
+            void 0,
+            varDeclList
+          );
+          statements.push(varStatement);
+          addRange(statements, exportStatements);
+          const condition = visitNode(node.condition, visitor, isExpression);
+          const incrementor = visitNode(node.incrementor, discardedValueVisitor, isExpression);
+          const body = visitIterationBody(node.statement, isTopLevel ? topLevelNestedVisitor : visitor, context);
+          statements.push(factory2.updateForStatement(
+            node,
+            /*initializer*/
+            void 0,
+            condition,
+            incrementor,
+            body
+          ));
+          return statements;
+        }
+      }
       return factory2.updateForStatement(
         node,
         visitNode(node.initializer, discardedValueVisitor, isForInitializer),
         visitNode(node.condition, visitor, isExpression),
         visitNode(node.incrementor, discardedValueVisitor, isExpression),
-        visitIterationBody(node.statement, visitor, context)
+        visitIterationBody(node.statement, isTopLevel ? topLevelNestedVisitor : visitor, context)
       );
     }
+    function visitForInStatement(node) {
+      if (isVariableDeclarationList(node.initializer) && !(node.initializer.flags & 3 /* BlockScoped */)) {
+        const exportStatements = appendExportsOfVariableDeclarationList(
+          /*statements*/
+          void 0,
+          node.initializer,
+          /*isForInOrOfInitializer*/
+          true
+        );
+        if (some(exportStatements)) {
+          const initializer = visitNode(node.initializer, discardedValueVisitor, isForInitializer);
+          const expression = visitNode(node.expression, visitor, isExpression);
+          const body = visitIterationBody(node.statement, topLevelNestedVisitor, context);
+          const mergedBody = isBlock(body) ? factory2.updateBlock(body, [...exportStatements, ...body.statements]) : factory2.createBlock(
+            [...exportStatements, body],
+            /*multiLine*/
+            true
+          );
+          return factory2.updateForInStatement(node, initializer, expression, mergedBody);
+        }
+      }
+      return factory2.updateForInStatement(
+        node,
+        visitNode(node.initializer, discardedValueVisitor, isForInitializer),
+        visitNode(node.expression, visitor, isExpression),
+        visitIterationBody(node.statement, topLevelNestedVisitor, context)
+      );
+    }
+    function visitForOfStatement(node) {
+      if (isVariableDeclarationList(node.initializer) && !(node.initializer.flags & 3 /* BlockScoped */)) {
+        const exportStatements = appendExportsOfVariableDeclarationList(
+          /*statements*/
+          void 0,
+          node.initializer,
+          /*isForInOrOfInitializer*/
+          true
+        );
+        const initializer = visitNode(node.initializer, discardedValueVisitor, isForInitializer);
+        const expression = visitNode(node.expression, visitor, isExpression);
+        let body = visitIterationBody(node.statement, topLevelNestedVisitor, context);
+        if (some(exportStatements)) {
+          body = isBlock(body) ? factory2.updateBlock(body, [...exportStatements, ...body.statements]) : factory2.createBlock(
+            [...exportStatements, body],
+            /*multiLine*/
+            true
+          );
+        }
+        return factory2.updateForOfStatement(node, node.awaitModifier, initializer, expression, body);
+      }
+      return factory2.updateForOfStatement(
+        node,
+        node.awaitModifier,
+        visitNode(node.initializer, discardedValueVisitor, isForInitializer),
+        visitNode(node.expression, visitor, isExpression),
+        visitIterationBody(node.statement, topLevelNestedVisitor, context)
+      );
+    }
+    function visitDoStatement(node) {
+      return factory2.updateDoStatement(
+        node,
+        visitIterationBody(node.statement, topLevelNestedVisitor, context),
+        visitNode(node.expression, visitor, isExpression)
+      );
+    }
+    function visitWhileStatement(node) {
+      return factory2.updateWhileStatement(
+        node,
+        visitNode(node.expression, visitor, isExpression),
+        visitIterationBody(node.statement, topLevelNestedVisitor, context)
+      );
+    }
+    function visitLabeledStatement(node) {
+      return factory2.updateLabeledStatement(
+        node,
+        node.label,
+        Debug.checkDefined(visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock))
+      );
+    }
+    function visitWithStatement(node) {
+      return factory2.updateWithStatement(
+        node,
+        visitNode(node.expression, visitor, isExpression),
+        Debug.checkDefined(visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock))
+      );
+    }
+    function visitIfStatement(node) {
+      return factory2.updateIfStatement(
+        node,
+        visitNode(node.expression, visitor, isExpression),
+        Debug.checkDefined(visitNode(node.thenStatement, topLevelNestedVisitor, isStatement, factory2.liftToBlock)),
+        visitNode(node.elseStatement, topLevelNestedVisitor, isStatement, factory2.liftToBlock)
+      );
+    }
+    function visitSwitchStatement(node) {
+      return factory2.updateSwitchStatement(
+        node,
+        visitNode(node.expression, visitor, isExpression),
+        Debug.checkDefined(visitNode(node.caseBlock, topLevelNestedVisitor, isCaseBlock))
+      );
+    }
+    function visitCaseBlock(node) {
+      return factory2.updateCaseBlock(
+        node,
+        visitNodes2(node.clauses, topLevelNestedVisitor, isCaseOrDefaultClause)
+      );
+    }
+    function visitCaseClause(node) {
+      return factory2.updateCaseClause(
+        node,
+        visitNode(node.expression, visitor, isExpression),
+        visitNodes2(node.statements, topLevelNestedVisitor, isStatement)
+      );
+    }
+    function visitDefaultClause(node) {
+      return visitEachChild(node, topLevelNestedVisitor, context);
+    }
+    function visitTryStatement(node) {
+      return visitEachChild(node, topLevelNestedVisitor, context);
+    }
+    function visitCatchClause(node) {
+      return factory2.updateCatchClause(
+        node,
+        node.variableDeclaration,
+        Debug.checkDefined(visitNode(node.block, topLevelNestedVisitor, isBlock))
+      );
+    }
+    function visitBlock(node) {
+      node = visitEachChild(node, topLevelNestedVisitor, context);
+      return node;
+    }
     function visitExpressionStatement(node) {
       return factory2.updateExpressionStatement(
         node,
@@ -105193,25 +105417,33 @@ ${lanes.join("\n")}
       return appendExportsOfDeclaration(statements, decl);
     }
     function appendExportsOfVariableStatement(statements, node) {
+      return appendExportsOfVariableDeclarationList(
+        statements,
+        node.declarationList,
+        /*isForInOrOfInitializer*/
+        false
+      );
+    }
+    function appendExportsOfVariableDeclarationList(statements, node, isForInOrOfInitializer) {
       if (currentModuleInfo.exportEquals) {
         return statements;
       }
-      for (const decl of node.declarationList.declarations) {
-        statements = appendExportsOfBindingElement(statements, decl);
+      for (const decl of node.declarations) {
+        statements = appendExportsOfBindingElement(statements, decl, isForInOrOfInitializer);
       }
       return statements;
     }
-    function appendExportsOfBindingElement(statements, decl) {
+    function appendExportsOfBindingElement(statements, decl, isForInOrOfInitializer) {
       if (currentModuleInfo.exportEquals) {
         return statements;
       }
       if (isBindingPattern(decl.name)) {
         for (const element of decl.name.elements) {
           if (!isOmittedExpression(element)) {
-            statements = appendExportsOfBindingElement(statements, element);
+            statements = appendExportsOfBindingElement(statements, element, isForInOrOfInitializer);
           }
         }
-      } else if (!isGeneratedIdentifier(decl.name) && (!isVariableDeclaration(decl) || decl.initializer)) {
+      } else if (!isGeneratedIdentifier(decl.name) && (!isVariableDeclaration(decl) || decl.initializer || isForInOrOfInitializer)) {
         statements = appendExportsOfDeclaration(statements, decl);
       }
       return statements;
@@ -178983,7 +179215,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
         getApplicableRefactors(args) {
           const { file, project } = this.getFileAndProject(args);
           const scriptInfo = project.getScriptInfoForNormalizedPath(file);
-          return project.getLanguageService().getApplicableRefactors(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file), args.triggerReason, args.kind);
+          return project.getLanguageService().getApplicableRefactors(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file), args.triggerReason, args.kind, args.includeInteractiveActions);
         }
         getEditsForRefactor(args, simplifiedResult) {
           const { file, project } = this.getFileAndProject(args);

package/lib/typescript.d.ts

@@ -550,7 +550,7 @@ declare namespace ts {
     interface FlowContainer extends Node {
         _flowContainerBrand: any;
     }
-    type HasJSDoc = AccessorDeclaration | ArrowFunction | BinaryExpression | Block | BreakStatement | CallSignatureDeclaration | CaseClause | ClassLikeDeclaration | ClassStaticBlockDeclaration | ConstructorDeclaration | ConstructorTypeNode | ConstructSignatureDeclaration | ContinueStatement | DebuggerStatement | DoStatement | ElementAccessExpression | EmptyStatement | EndOfFileToken | EnumDeclaration | EnumMember | ExportAssignment | ExportDeclaration | ExportSpecifier | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | FunctionTypeNode | Identifier | IfStatement | ImportDeclaration | ImportEqualsDeclaration | IndexSignatureDeclaration | InterfaceDeclaration | JSDocFunctionType | JSDocSignature | LabeledStatement | MethodDeclaration | MethodSignature | ModuleDeclaration | NamedTupleMember | NamespaceExportDeclaration | ObjectLiteralExpression | ParameterDeclaration | ParenthesizedExpression | PropertyAccessExpression | PropertyAssignment | PropertyDeclaration | PropertySignature | ReturnStatement | ShorthandPropertyAssignment | SpreadAssignment | SwitchStatement | ThrowStatement | TryStatement | TypeAliasDeclaration | TypeParameterDeclaration | VariableDeclaration | VariableStatement | WhileStatement | WithStatement;
+    type HasJSDoc = AccessorDeclaration | ArrowFunction | BinaryExpression | Block | BreakStatement | CallSignatureDeclaration | CaseClause | ClassLikeDeclaration | ClassStaticBlockDeclaration | ConstructorDeclaration | ConstructorTypeNode | ConstructSignatureDeclaration | ContinueStatement | DebuggerStatement | DoStatement | ElementAccessExpression | EmptyStatement | EndOfFileToken | EnumDeclaration | EnumMember | ExportAssignment | ExportDeclaration | ExportSpecifier | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | FunctionTypeNode | Identifier | IfStatement | ImportDeclaration | ImportEqualsDeclaration | IndexSignatureDeclaration | InterfaceDeclaration | JSDocFunctionType | JSDocSignature | LabeledStatement | MethodDeclaration | MethodSignature | ModuleDeclaration | NamedTupleMember | NamespaceExportDeclaration | ObjectLiteralExpression | ParameterDeclaration | ParenthesizedExpression | PropertyAccessExpression | PropertyAssignment | PropertyDeclaration | PropertySignature | ReturnStatement | SemicolonClassElement | ShorthandPropertyAssignment | SpreadAssignment | SwitchStatement | ThrowStatement | TryStatement | TypeAliasDeclaration | TypeParameterDeclaration | VariableDeclaration | VariableStatement | WhileStatement | WithStatement;
     type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocVariadicType;
     type HasTypeArguments = CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement | JsxSelfClosingElement;
     type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute;
@@ -829,7 +829,7 @@ declare namespace ts {
         readonly body?: FunctionBody | undefined;
     }
     /** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */
-    interface SemicolonClassElement extends ClassElement {
+    interface SemicolonClassElement extends ClassElement, JSDocContainer {
         readonly kind: SyntaxKind.SemicolonClassElement;
         readonly parent: ClassLikeDeclaration;
     }