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

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230427`;
+var version = `${versionMajorMinor}.0-dev.20230429`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -13734,6 +13734,7 @@ function canHaveJSDoc(node) {
     case 171 /* PropertyDeclaration */:
     case 170 /* PropertySignature */:
     case 252 /* ReturnStatement */:
+    case 239 /* SemicolonClassElement */:
     case 177 /* SetAccessor */:
     case 303 /* ShorthandPropertyAssignment */:
     case 304 /* SpreadAssignment */:
@@ -31102,11 +31103,11 @@ var Parser;
   }
   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,
@@ -43641,13 +43642,14 @@ function createTypeChecker(host) {
     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, isDeprecatedDeclaration) : every(symbol.declarations, isDeprecatedDeclaration);
     }
-    return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 268435456 /* Deprecated */);
+    return !!symbol.valueDeclaration && isDeprecatedDeclaration(symbol.valueDeclaration) || length(symbol.declarations) && every(symbol.declarations, isDeprecatedDeclaration);
+  }
+  function isDeprecatedDeclaration(declaration) {
+    return !!(getCombinedNodeFlags(declaration) & 268435456 /* Deprecated */);
   }
   function addDeprecatedSuggestion(location, declarations, deprecatedEntity) {
     const diagnostic = createDiagnosticForNode(location, Diagnostics._0_is_deprecated, deprecatedEntity);
@@ -65807,7 +65809,7 @@ function createTypeChecker(host) {
       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);
     }
@@ -68811,8 +68813,9 @@ function createTypeChecker(host) {
         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));
@@ -79088,19 +79091,17 @@ function createTypeChecker(host) {
         }
       }
       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;
@@ -79110,7 +79111,7 @@ function createTypeChecker(host) {
         if (target === targetSymbol)
           break;
         if (target.declarations && length(target.declarations)) {
-          if (isDeprecatedAliasedSymbol(target)) {
+          if (isDeprecatedSymbol(target)) {
             addDeprecatedSuggestion(location, target.declarations, target.escapedName);
             break;
           } else {
@@ -90413,6 +90414,19 @@ function transformLegacyDecorators(context) {
     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,
@@ -90429,7 +90443,7 @@ function transformLegacyDecorators(context) {
       void 0,
       /*type*/
       void 0,
-      classAlias ? factory2.createAssignment(classAlias, classExpression) : classExpression
+      classAlias && !assignClassAliasInStaticBlock ? factory2.createAssignment(classAlias, classExpression) : classExpression
     );
     setOriginalNode(varDecl, node);
     let varModifiers;
@@ -101412,12 +101426,56 @@ function transformModule(context) {
         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);
     }
@@ -101428,7 +101486,11 @@ function transformModule(context) {
     }
     switch (node.kind) {
       case 247 /* ForStatement */:
-        return visitForStatement(node);
+        return visitForStatement(
+          node,
+          /*isTopLevel*/
+          false
+        );
       case 243 /* ExpressionStatement */:
         return visitExpressionStatement(node);
       case 216 /* ParenthesizedExpression */:
@@ -101513,15 +101575,177 @@ function transformModule(context) {
     }
     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,
@@ -102314,25 +102538,33 @@ function transformModule(context) {
     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;